#include "NaviDAQPropertySpec.h"

//////////////////////
SPEC_PROPERTY Type_PropertyMap::content[TYPE_PROPERTYMAP] = {
    AI_AiCtrl_ChannelCount,	"AI.AiCtrl.ChannelCount",
	AI_AiCtrl_Channel,	"AI.AiCtrl.Channel",
	AI_AiCtrl_Feature_Resolution,	"AI.AiCtrl.Feature.Resolution",
	AI_AiCtrl_Feature_DataSize,	"AI.AiCtrl.Feature.DataSize",
	AI_AiCtrl_Feature_DataMask,	"AI.AiCtrl.Feature.DataMask",
	AI_AiCtrl_Feature_ChannelCountMax,	"AI.AiCtrl.Feature.ChannelCountMax",
	AI_AiCtrl_Feature_ChannelType,	"AI.AiCtrl.Feature.ChannelType",
	AI_AiCtrl_Feature_OverallValueRange,	"AI.AiCtrl.Feature.OverallValueRange",
	AI_AiCtrl_Feature_Thermosupported,	"AI.AiCtrl.Feature.Thermosupported",
	AI_AiCtrl_Feature_ValueRanges,	"AI.AiCtrl.Feature.ValueRanges",
	AI_AiCtrl_Feature_BufferedAiSupported,	"AI.AiCtrl.Feature.BufferedAiSupported",
	AI_AiCtrl_Feature_ChannelStartBase,	"AI.AiCtrl.Feature.ChannelStartBase",
	AI_AiCtrl_Feature_ChannelCountBase,	"AI.AiCtrl.Feature.ChannelCountBase",
	AI_AiCtrl_Feature_ConvertClockSources,	"AI.AiCtrl.Feature.ConvertClockSources",
	AI_AiCtrl_Feature_ConvertClockRange,	"AI.AiCtrl.Feature.ConvertClockRange",
	AI_AiCtrl_Feature_SamplingMethod,	"AI.AiCtrl.Feature.SamplingMethod",
	AI_AiCtrl_Feature_BurstScanSupported,	"AI.AiCtrl.Feature.BurstScanSupported",
	AI_AiCtrl_Feature_ScanClockRange,	"AI.AiCtrl.Feature.ScanClockRange",
	AI_AiCtrl_Feature_ScanClockSources,	"AI.AiCtrl.Feature.ScanClockSources",
	AI_AiCtrl_Feature_ScanCountMax,	"AI.AiCtrl.Feature.ScanCountMax",
	AI_AiCtrl_Feature_TriggerSupported,	"AI.AiCtrl.Feature.TriggerSupported",
	AI_AiCtrl_Feature_TriggerCount,	"AI.AiCtrl.Feature.TriggerCount",
	AI_AiCtrl_Feature_TriggerSources,	"AI.AiCtrl.Feature.TriggerSources",
	AI_AiCtrl_Feature_TriggerActions,	"AI.AiCtrl.Feature.TriggerActions",
	AI_AiCtrl_Feature_TriggerDelayRange,	"AI.AiCtrl.Feature.TriggerDelayRange",
	AI_BufferedAiCtrl_Streaming,	"AI.BufferedAiCtrl.Streaming",
	AI_BufferedAiCtrl_ConvertClock_Rate,	"AI.BufferedAiCtrl.ConvertClock.Rate",
	AI_BufferedAiCtrl_ConvertClock_Source,	"AI.BufferedAiCtrl.ConvertClock.Source",
	AI_BufferedAiCtrl_ScanClock_Rate,	"AI.BufferedAiCtrl.ScanClock.Rate",
	AI_BufferedAiCtrl_ScanClock_Source,	"AI.BufferedAiCtrl.ScanClock.Source",
	AI_BufferedAiCtrl_ScanClock_ScanCount,	"AI.BufferedAiCtrl.ScanClock.ScanCount",
	AI_BufferedAiCtrl_ScanChannel_ChannelStart,	"AI.BufferedAiCtrl.ScanChannel.ChannelStart",
	AI_BufferedAiCtrl_ScanChannel_ChannelCount,	"AI.BufferedAiCtrl.ScanChannel.ChannelCount",
	AI_BufferedAiCtrl_ScanChannel_IntervalCount,	"AI.BufferedAiCtrl.ScanChannel.IntervalCount",
	AI_BufferedAiCtrl_ScanChannel_Samples,	"AI.BufferedAiCtrl.ScanChannel.Samples",
	AI_BufferedAiCtrl_Trigger_Source,	"AI.BufferedAiCtrl.Trigger.Source",
	AI_BufferedAiCtrl_Trigger_Edge,	"AI.BufferedAiCtrl.Trigger.Edge",
	AI_BufferedAiCtrl_Trigger_Level,	"AI.BufferedAiCtrl.Trigger.Level",
	AI_BufferedAiCtrl_Trigger_Action,	"AI.BufferedAiCtrl.Trigger.Action",
	AI_BufferedAiCtrl_Trigger_DelayCount,	"AI.BufferedAiCtrl.Trigger.DelayCount",
	Counter_CntrFeatures_Resolution,	"Counter.CntrFeatures.Resolution",
	Counter_CntrFeatures_Capabilityies,	"Counter.CntrFeatures.Capabilityies",
	Counter_CntrFeatures_ChannelCountMax,	"Counter.CntrFeatures.ChannelCountMax",
	Counter_CntrFeatures_DataSize,	"Counter.CntrFeatures.DataSize",
	Counter_EventCountCtrl_Value,	"Counter.EventCountCtrl.Value",
	Counter_FreqMeterCtrl_Features_FmMethods,	"Counter.FreqMeterCtrl.Features.FmMethods",
	Counter_FreqMeterCtrl_Value,	"Counter.FreqMeterCtrl.Value",
	Counter_FreqMeterCtrl_Method,	"Counter.FreqMeterCtrl.Method",
	Counter_OneShotCtrl_Features_DelayCountRange,	"Counter.OneShotCtrl.Features.DelayCountRange",
	Counter_OneShotCtrl_Features_OneShotEventSupported,	"Counter.OneShotCtrl.Features.OneShotEventSupported",
	Counter_OneShotCtrl_DelayCount,	"Counter.OneShotCtrl.DelayCount",
	Counter_TimerPulseCtrl_Features_TimerEventSupported,	"Counter.TimerPulseCtrl.Features.TimerEventSupported",
	Counter_TimerPulseCtrl_Features_TimerFrequencyRange,	"Counter.TimerPulseCtrl.Features.TimerFrequencyRange",
	Counter_TimerPulseCtrl_Frequency,	"Counter.TimerPulseCtrl.Frequency",
	Counter_PwMeterCtrl_Features_OverflowEventSupported,	"Counter.PwMeterCtrl.Features.OverflowEventSupported",
	Counter_PwMeterCtrl_Value,	"Counter.PwMeterCtrl.Value",
	Counter_PwModulatorCtrl_Features_HiPeriodRange,	"Counter.PwModulatorCtrl.Features.HiPeriodRange",
	Counter_PwModulatorCtrl_Features_LoPeriodRange,	"Counter.PwModulatorCtrl.Features.LoPeriodRange",
	Counter_PwModulatorCtrl_PulseWidth,	"Counter.PwModulatorCtrl.PulseWidth",
	AO_AoCtrlBase_ChannelCount,	"AO.AoCtrlBase.ChannelCount",		
	AO_AoCtrlBase_Channels,	"AO.AoCtrlBase.Channels",							
	AO_AoCtrlBase_Features_Resolution,	"AO.AoCtrlBase.Features.Resolution",				
	AO_AoCtrlBase_Features_DataSize,	"AO.AoCtrlBase.Features.DataSize",					
	AO_AoCtrlBase_Features_DataMask,	"AO.AoCtrlBase.Features.DataMask",				
	AO_AoCtrlBase_Features_ChannelCountMax,	"AO.AoCtrlBase.Features.ChannelCountMax",			
	AO_AoCtrlBase_Features_ValueRanges,	"AO.AoCtrlBase.Features.ValueRanges",				
	AO_AoCtrlBase_Features_BufferedAoSupported,	"AO.AoCtrlBase.Features.BufferedAoSupported",		
	DIO_DiCtrlBase_PortCount,	"DIO.DiCtrlBase.PortCount",					
	DIO_DiCtrlBase_PortDirection,	"DIO.DiCtrlBase.PortDirection",					
	DIO_DiCtrlBase_Features_ChannelCountMax,	"DIO.DiCtrlBase.Features.ChannelCountMax",			
	DIO_DiCtrlBase_Features_PortCount,	"DIO.DiCtrlBase.Features.PortCount",				
	DIO_DiCtrlBase_Features_PortProgrammable,	"DIO.DiCtrlBase.Features.PortProgrammable",		
	DIO_DiCtrlBase_Features_PortsType,	"DIO.DiCtrlBase.Features.PortsType",				
	DIO_DiCtrlBase_Features_DataMask,	"DIO.DiCtrlBase.Features.DataMask",				
	DIO_DiCtrlBase_Features_NoiseFilterSupported,	"DIO.DiCtrlBase.Features.NoiseFilterSupported",	
	DIO_DiCtrlBase_Features_DiintSupported,	"DIO.DiCtrlBase.Features.DiintSupported",			
	DIO_DiCtrlBase_Features_DiintGateSupported,	"DIO.DiCtrlBase.Features.DiintGateSupported",		
	DIO_DiCtrlBase_Features_DiPmintSupported,	"DIO.DiCtrlBase.Features.DiPmintSupported",		
	DIO_DiCtrlBase_Features_DiCosintSupported,	"DIO.DiCtrlBase.Features.DiCosintSupported",		
	DIO_DoCtrlBase_PortCount,	"DIO.DoCtrlBase.PortCount",					
	DIO_DoCtrlBase_Portdirection,	"DIO.DoCtrlBase.Portdirection",					
	DIO_DoCtrlBase_Features_ChannelCountMax,	"DIO.DoCtrlBase.Features.ChannelCountMax",			
	DIO_DoCtrlBase_Features_PortCount,	"DIO.DoCtrlBase.Features.PortCount",				
	DIO_DoCtrlBase_Features_PortProgrammable,	"DIO.DoCtrlBase.Features.PortProgrammable",		
	DIO_DoCtrlBase_Features_PortsType,	"DIO.DoCtrlBase.Features.PortsType",				
	DIO_DoCtrlBase_Features_DataMask,	"DIO.DoCtrlBase.Features.DataMask",
	AO_AoCtrlBase_ExtRefValueForUnipolar,	"AO.AoCtrlBase.ExtRefValueForUnipolar",
	AO_AoCtrlBase_ExtRefValueForBipolar,	"AO.AoCtrlBase.ExtRefValueForBipolar",
	AO_AoCtrlBase_Features_ExternalRefAntiPolar,	"AO.AoCtrlBase.Features.ExternalRefAntiPolar",
	AO_AoCtrlBase_Features_ExternalRefRange,	"AO.AoCtrlBase.Features.ExternalRefRange",
	Counter_FreqMeterCtrl_CollectionPeriod,	"Counter.FreqMeterCtrl.CollectionPeriod",
    AI_AiCtrlBase_ScanChannel_ChannelStart, "AI.AiCtrlBase.ScanChannel.ChannelStar",
    AI_AiCtrlBase_ScanChannel_ChannelCount, "AI.AiCtrlBase.ScanChannel.ChannelCount",
    AI_AiCtrlBase_ScanChannel_Samples,  "AI.AiCtrlBase.ScanChannel.Samples",
    AI_AiCtrlBase_ScanChannel_IntervalCount,    "AI.AiCtrlBase.ScanChannel.IntervalCount",
    AI_AiChannel_Gain,  "AI.AiChannel.Gain",
    AO_AOChannel_Gain,  "AO.AOChannel.Gain",
    AO_AOChannel_InitOutputValue,   "AO.AOChannel.InitOutputValue",
    Counter_EventCount_ClockPolarity, "Counter.EventCount.ClockPolarity",
    Counter_EventCount_GateEnable,    "Counter.EventCount.GateEnable",
    Counter_EventCount_GatePolarity,  "Counter.EventCount.GatePolarity",
	Counter_OneShot_ClkSource,		"Counter.OneShot.ClkSource",
	Counter_OneShot_ClkPolarity,	"Counter.OneShot.ClkPolarity",
	Counter_OneShot_GateSource,		"Counter.OneShot.GateSource",
	Counter_OneShot_GatePolarity,	"Counter.OneShot.GatePolarity",
	Counter_OneShot_OutSignal,		"Counter.OneShot.OutSignal",
	Counter_OneShot_DelayCount,		"Counter.OneShot.DelayCount",
	Counter_TimerPulse_GateEnable,	"Counter.TimerPulse.GateEnable",
	Counter_TimerPulse_GatePolarity,	"Counter.TimerPulse.GatePolarity",
	Counter_TimerPulse_OutSignal,	"Counter.TimerPulse.OutSignal",
	Counter_TimerPulse_TimerFrequency,	"Counter.TimerPulse.TimerFrequency",
	Counter_FreqMeasure_Method,	"Counter.FreqMeasure.Method",
	Counter_FreqMeasure_MeasurePeriod,	"Counter.FreqMeasure.MeasurePeriod",
	Counter_PulseWidth_GateEnable,	"Counter.PulseWidth.GateEnable",
	Counter_PulseWidth_GatePolarity,	"Counter.PulseWidth.GatePolarity",
	Counter_PulseWidth_HighPeriod,	"Counter.PulseWidth.HighPeriod",
	Counter_PulseWidth_LowPeriod,	"Counter.PulseWidth.LowPeriod",
};

int Type_PropertyMap::count = TYPE_PROPERTYMAP;

char* Type_PropertyMap::GetPropertySpec(int id)
{
	for (int i = 0; i < Type_PropertyMap::count; ++i)
	{
		if (Type_PropertyMap::content[i].iID == id)
		{
			return Type_PropertyMap::content[i].strSpec;
		}
	}
	return "undefine ID";
}

int Type_PropertyMap::GetPropertyID(char* caption)
{
	for (int i = 0; i < Type_PropertyMap::count; ++i)
	{
        if (0 == strcmp(caption,Type_PropertyMap::content[i].strSpec))
		{
			return Type_PropertyMap::content[i].iID;
		}
	}
	return -1;
}

///////////////////////////////////////
SPEC_PROPERTY Type_TerminalBoard::content[TYPE_TERMINALBOARD] = {
    WiringBoard,	"WiringBoard",
        PCLD8710,	"WiringBoard",
        PCLD789,	"WiringBoard",
        PCLD8115,	"WiringBoard"
};

int Type_TerminalBoard::count = TYPE_TERMINALBOARD;

char*  Type_TerminalBoard::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_TerminalBoard::count; ++i)
    {
        if (Type_TerminalBoard::content[i].iID == id)
        {
            return Type_TerminalBoard::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_TerminalBoard::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_TerminalBoard::count; ++i)
    {
        if (0 == strcmp(caption,Type_TerminalBoard::content[i].strSpec))
        {
            return Type_TerminalBoard::content[i].iID;
        }
    }
    return -1;
}

////////////////////////////////////
SPEC_PROPERTY Type_ModuleType::content[TYPE_MODULETYPE] = {
    DaqAny,	"DaqAny",
        DaqGroup,	"DaqGroup",
        DaqDevice,	"DaqDevice",
        DaqAi,	"DaqAi",
        DaqAo,	"DaqAo",
        DaqDio,	"DaqDio",
        DaqCounter,	"DaqCounter"
};

int Type_ModuleType::count = TYPE_MODULETYPE;

char* Type_ModuleType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_ModuleType::count; ++i)
    {
        if (Type_ModuleType::content[i].iID == id)
        {
            return Type_ModuleType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_ModuleType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_ModuleType::count; ++i)
    {
        if (0 == strcmp(caption,Type_ModuleType::content[i].strSpec))
        {
            return Type_ModuleType::content[i].iID;
        }
    }
    return -1;
}


//////////////////////
SPEC_PROPERTY Type_AccessMode::content[TYPE_ACCESSMODE] = {
    ModeRead,	"ModeRead",
        ModeWrite,	"ModeWrite",
        ModeWriteWithReset,	"ModeWriteWithReset",
        ModeReserved, "ModeReserved"
};

int Type_AccessMode::count = TYPE_ACCESSMODE;

char* Type_AccessMode::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_AccessMode::count; ++i)
    {
        if (Type_AccessMode::content[i].iID == id)
        {
            return Type_AccessMode::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_AccessMode::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_AccessMode::count; ++i)
    {
        if (0 == strcmp(caption,Type_AccessMode::content[i].strSpec))
        {
            return Type_AccessMode::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_MathIntervalType::content[TYPE_MATHINTERVALTYPE] = {
    RightOpenSet,	"RightOpenSet",
        RightClosedBoundary,	"RightClosedBoundary",
        RightOpenBoundary,	"RightOpenBoundary",
        LeftOpenSet,	"LeftOpenSet",
        LeftClosedBoundary,	"LeftClosedBoundary",
        LeftOpenBoundary,	"LeftOpenBoundary",
        Boundless,	"Boundless",
        LOSROS,	"LOSROS",
        LOSRCB,	"LOSRCB",
        LOSROB,	"LOSROB",
        LCBROS,	"LCBROS",
        LCBRCB,	"LCBRCB",
        LCBROB,	"LCBROB",
        LOBROS,	"LOBROS",
        LOBRCB,	"LOBRCB",
        LOBROB,	"LOBROB"
};

int Type_MathIntervalType::count = TYPE_MATHINTERVALTYPE;

char* Type_MathIntervalType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_MathIntervalType::count; ++i)
    {
        if (Type_MathIntervalType::content[i].iID == id)
        {
            return Type_MathIntervalType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_MathIntervalType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_MathIntervalType::count; ++i)
    {
        if (0 == strcmp(caption,Type_MathIntervalType::content[i].strSpec))
        {
            return Type_MathIntervalType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
char Type_MathInterval::outdata[200] = {0};
char* Type_MathInterval::GetPropertySpec(MathInterval* pContent)
{
    char* pch = &(Type_MathInterval::outdata[0]);
    sprintf(pch, "Type: %d, Max: %lf, Min: %lf", pContent->Type, pContent->Max, pContent->Min);
    return pch;
}

//////////////////////
SPEC_PROPERTY Type_AiChannelType::content[TYPE_AICHANNELTYPE] = {
    AllSingleEnded,	"AllSingleEnded",
        AllDifferential,	"AllDifferential",
        AllSeDiffAdj,	"AllSeDiffAdj",
        MixedSeDiffAdj,	"MixedSeDiffAdj"
};

int Type_AiChannelType::count = TYPE_AICHANNELTYPE;

char* Type_AiChannelType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_AiChannelType::count; ++i)
    {
        if (Type_AiChannelType::content[i].iID == id)
        {
            return Type_AiChannelType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_AiChannelType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_AiChannelType::count; ++i)
    {
        if (0 == strcmp(caption,Type_AiChannelType::content[i].strSpec))
        {
            return Type_AiChannelType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_AiSignalType::content[TYPE_AISIGNALTYPE] = {
    SingleEnded,	"SingleEnded",
        Differential,	"Differential",
};

int Type_AiSignalType::count = TYPE_AISIGNALTYPE;

char* Type_AiSignalType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_AiSignalType::count; ++i)
    {
        if (Type_AiSignalType::content[i].iID == id)
        {
            return Type_AiSignalType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_AiSignalType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_AiSignalType::count; ++i)
    {
        if (0 == strcmp(caption,Type_AiSignalType::content[i].strSpec))
        {
            return Type_AiSignalType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_FilterType::content[TYPE_FILTERTYPE] = {
    FilterNone,     "FilterNone",
    LowPass,        "LowPass",    
    HighPass,       "HighPass",
    BandPass,       "BandPass",
    BandStop,       "BandStop",
};

int Type_FilterType::count = TYPE_FILTERTYPE;

char* Type_FilterType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_FilterType::count; ++i)
    {
        if (Type_FilterType::content[i].iID == id)
        {
            return Type_FilterType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_FilterType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_FilterType::count; ++i)
    {
        if (0 == strcmp(caption,Type_FilterType::content[i].strSpec))
        {
            return Type_FilterType::content[i].iID;
        }
    }
    return -1;
}



//////////////////////
SPEC_PROPERTY Type_DioPortType::content[TYPE_DIOPORTTYPE] = {
    PortDi,	"PortDi",
        PortDo,	"PortDo",
        PortDio,	"PortDio",
        Port8255A,	"Port8255A",
        Port8255C,	"Port8255C",
        PortIndvdlDio,	"PortIndvdlDio"
};

int Type_DioPortType::count = TYPE_DIOPORTTYPE;

char* Type_DioPortType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_DioPortType::count; ++i)
    {
        if (Type_DioPortType::content[i].iID == id)
        {
            return Type_DioPortType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_DioPortType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_DioPortType::count; ++i)
    {
        if (0 == strcmp(caption,Type_DioPortType::content[i].strSpec))
        {
            return Type_DioPortType::content[i].iID;
        }
    }
    return -1;
}


//////////////////////
SPEC_PROPERTY Type_DioPortDir::content[TYPE_DIOPORTDIR] = {
    Input,	"Input",
        LoutHin,	"LoutHin",
        LinHout,	"LinHout",
        Output,	"Output"
};

int Type_DioPortDir::count = TYPE_DIOPORTDIR;

char* Type_DioPortDir::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_DioPortDir::count; ++i)
    {
        if (Type_DioPortDir::content[i].iID == id)
        {
            return Type_DioPortDir::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_DioPortDir::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_DioPortDir::count; ++i)
    {
        if (0 == strcmp(caption,Type_DioPortDir::content[i].strSpec))
        {
            return Type_DioPortDir::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_SamplingMethod::content[TYPE_SAMPLINGMETHOD] = {
    EqualTimeSwitch,	"EqualTimeSwitch",
        Simultaneous,	"Simultaneous"
};

int Type_SamplingMethod::count = TYPE_SAMPLINGMETHOD;

char* Type_SamplingMethod::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_SamplingMethod::count; ++i)
    {
        if (Type_SamplingMethod::content[i].iID == id)
        {
            return Type_SamplingMethod::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_SamplingMethod::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_SamplingMethod::count; ++i)
    {
        if (0 == strcmp(caption,Type_SamplingMethod::content[i].strSpec))
        {
            return Type_SamplingMethod::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_TemperatureDegree::content[TYPE_TEMPERATUREDEGREE] = {
    Celsius,	"Celsius",
        Fahrenheit,	"Fahrenheit",
        Rankine,	"Rankine",
        Kelvin,	"Kelvin"
};

int Type_TemperatureDegree::count = TYPE_TEMPERATUREDEGREE;

char* Type_TemperatureDegree::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_TemperatureDegree::count; ++i)
    {
        if (Type_TemperatureDegree::content[i].iID == id)
        {
            return Type_TemperatureDegree::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_TemperatureDegree::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_TemperatureDegree::count; ++i)
    {
        if (0 == strcmp(caption,Type_TemperatureDegree::content[i].strSpec))
        {
            return Type_TemperatureDegree::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_BurnoutRetType::content[TYPE_BURNOUTRETTYPE] = {
    Current,	"Current",
        ParticularValue,	"ParticularValue",
        UpLimit,	"UpLimit",
        LowLimit,	"LowLimit",
        LastCorrectValue,	"LastCorrectValue"
};

int Type_BurnoutRetType::count = TYPE_BURNOUTRETTYPE;

char* Type_BurnoutRetType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_BurnoutRetType::count; ++i)
    {
        if (Type_BurnoutRetType::content[i].iID == id)
        {
            return Type_BurnoutRetType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_BurnoutRetType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_BurnoutRetType::count; ++i)
    {
        if (0 == strcmp(caption,Type_BurnoutRetType::content[i].strSpec))
        {
            return Type_BurnoutRetType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_ValueUnit::content[TYPE_VALUEUNIT] = {
    Kilovolt,	"Kilovolt",
        Volt,	"Volt",
        Millivolt,	"Millivolt",
        Microvolt,	"Microvolt",
        Kiloampere,	"Kiloampere",
        Ampere,	"Ampere",
        Milliampere,	"Milliampere",
        Microampere,	"Microampere",
        CelsiusUnit,	"CelsiusUnit"
};

int Type_ValueUnit::count = TYPE_VALUEUNIT;

char* Type_ValueUnit::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_ValueUnit::count; ++i)
    {
        if (Type_ValueUnit::content[i].iID == id)
        {
            return Type_ValueUnit::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_ValueUnit::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_ValueUnit::count; ++i)
    {
        if (0 == strcmp(caption,Type_ValueUnit::content[i].strSpec))
        {
            return Type_ValueUnit::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_ValueRange::content[TYPE_VALUERANGE] = {
	V_OMIT,	"V_OMIT",
	V_Neg15To15,	"V_Neg15To15",
	V_Neg10To10,	"V_Neg10To10",
	V_Neg5To5,	"V_Neg5To5",
	V_Neg2pt5To2pt5,	"V_Neg2pt5To2pt5",
	V_Neg1pt25To1pt25,	"V_Neg1pt25To1pt25",
	V_Neg1To1,	"V_Neg1To1",
	V_0To15,	"V_0To15",
	V_0To10,	"V_0To10",
	V_0To5,	    "V_0To5",
	V_0To2pt5,	"V_0To2pt5",
	V_0To1pt25,	"V_0To1pt25",
	V_0To1,	"V_0To1",
	mV_Neg625To625,	"mV_Neg625To625",
	mV_Neg500To500,	"mV_Neg500To500",
	mV_Neg312pt5To312pt5,	"mV_Neg312pt5To312pt5",
	mV_Neg200To200,	"mV_Neg200To200",
	mV_Neg150To150,	"mV_Neg150To150",
	mV_Neg100To100,	"mV_Neg100To100",
	mV_Neg50To50,	"mV_Neg50To50",
	mV_Neg30To30,	"mV_Neg30To30",
	mV_Neg20To20,	"mV_Neg20To20",
	mV_Neg15To15,	"mV_Neg15To15",
	mV_Neg10To10,	"mV_Neg10To10",
	mV_Neg5To5,	"mV_Neg5To5",
	mV_0To625,	"mV_0To625",
	mV_0To500,	"mV_0To500",
	mV_0To150,	"mV_0To150",
	mV_0To100,	"mV_0To100",
	mV_0To50,	"mV_0To50",
    mV_0To20,	"mV_0To20",
    mV_0To15,	"mV_0To15",
    mV_0To10,	"mV_0To10",
	mA_Neg20To20,	"mA_Neg20To20",
	mA_0To20,	"mA_0To20",
	mA_4To20,	"mA_4To20",
	mA_0To24,	"mA_0To24",
	V_Neg2To2,	"V_Neg2To2",
	V_Neg4To4,	"V_Neg4To4",
	V_Neg20To20,	"V_Neg20To20",
	Jtype_0To760C,	"Jtype_0To760C",
	Ktype_0To1370C,	"Ktype_0To1370C",
	Ttype_Neg100To400C,	"Ttype_Neg100To400C",
	Etype_0To1000C,	"Etype_0To1000C",
	Rtype_500To1750C,	"Rtype_500To1750C",
	Stype_500To1750C,	"Stype_500To1750C",
	Btype_500To1800C,	"Btype_500To1800C",
	Pt392_Neg50To150,	"Pt392_Neg50To150",
	Pt385_Neg200To200,	"Pt385_Neg200To200",
	Pt385_0To400,	"Pt385_0To400",
	Pt385_Neg50To150,	"Pt385_Neg50To150",
	Pt385_Neg100To100,	"Pt385_Neg100To100",
	Pt385_0To100,	"Pt385_0To100",
	Pt385_0To200,	"Pt385_0To200",
	Pt385_0To600,	"Pt385_0To600",
	Pt392_Neg100To100,	"Pt392_Neg100To100",
	Pt392_0To100,	"Pt392_0To100",
	Pt392_0To200,	"Pt392_0To200",
	Pt392_0To600,	"Pt392_0To600",
	Pt392_0To400,	"Pt392_0To400",
	Pt392_Neg200To200,	"Pt392_Neg200To200",
	Pt1000_Neg40To160,	"Pt1000_Neg40To160",
	Balcon500_Neg30To120,	"Balcon500_Neg30To120",
	Ni518_Neg80To100,	"Ni518_Neg80To100",
	Ni518_0To100,	"Ni518_0To100",
	Ni508_0To100,	"Ni508_0To100",
	Ni508_Neg50To200,	"Ni508_Neg50To200",
	Thermistor_3K_0To100,	"Thermistor_3K_0To100",
	Thermistor_10K_0To100,	"Thermistor_10K_0To100",
	Jtype_Neg210To1200C,	"Jtype_Neg210To1200C",
	Ktype_Neg270To1372C,	"Ktype_Neg270To1372C",
	Ttype_Neg270To400C,	"Ttype_Neg270To400C",
	Etype_Neg270To1000C,	"Etype_Neg270To1000C",
	Rtype_Neg50To1768C,	"Rtype_Neg50To1768C",
	Stype_Neg50To1768C,	"Stype_Neg50To1768C",
	Btype_40To1820C,	"Btype_40To1820C",
	Jtype_Neg210To870C,	"Jtype_Neg210To870C",
	Rtype_0To1768C,	"Rtype_0To1768C",
	Ttype_Neg20To135C,	"Ttype_Neg20To135C",
	UserCustomizedVrgStart,	"UserCustomizedVrgStart",
	UserCustomizedVrgEnd,	"UserCustomizedVrgEnd",
	V_ExternalRefBipolar,	"V_ExternalRefBipolar",
	V_ExternalRefUnipolar,	"V_ExternalRefUnipolar"
};

int Type_ValueRange::count = TYPE_VALUERANGE;

char* Type_ValueRange::GetPropertySpec(int id)
{
	for (int i = 0; i < Type_ValueRange::count; ++i)
	{
		if (Type_ValueRange::content[i].iID == id)
		{
			return Type_ValueRange::content[i].strSpec;
		}
	}
	return "undefine ID";
}

int Type_ValueRange::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_ValueRange::count; ++i)
    {
        if (0 == strcmp(caption,Type_ValueRange::content[i].strSpec))
        {
            return Type_ValueRange::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_SignalPolarity::content[TYPE_SIGNALPOLARITY] = {
    Negative,	"Negative",
        Positive,	"Positive"
};

int Type_SignalPolarity::count = TYPE_SIGNALPOLARITY;

char* Type_SignalPolarity::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_SignalPolarity::count; ++i)
    {
        if (Type_SignalPolarity::content[i].iID == id)
        {
            return Type_SignalPolarity::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_SignalPolarity::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_SignalPolarity::count; ++i)
    {
        if (0 == strcmp(caption,Type_SignalPolarity::content[i].strSpec))
        {
            return Type_SignalPolarity::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_SignalCountingType::content[TYPE_SIGNALCOUNTINGTYPE] = {
    CountingNone, "CountingNone",
    DownCount,	"DownCount",
        UpCount,	"UpCount",
        PulseDirection,	"PulseDirection",
        TwoPulse,	"TwoPulse",
        AbPhaseX1,	"AbPhaseX1",
        AbPhaseX2,	"AbPhaseX2",
        AbPhaseX4,	"AbPhaseX4"
};

int Type_SignalCountingType::count = TYPE_SIGNALCOUNTINGTYPE;

char* Type_SignalCountingType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_SignalCountingType::count; ++i)
    {
        if (Type_SignalCountingType::content[i].iID == id)
        {
            return Type_SignalCountingType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_SignalCountingType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_SignalCountingType::count; ++i)
    {
        if (0 == strcmp(caption,Type_SignalCountingType::content[i].strSpec))
        {
            return Type_SignalCountingType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_OutSignalType::content[TYPE_OUTSIGNALTYPE] = {
    SignalOutNone,	"SignalOutNone",
        ChipDefined,	"ChipDefined",
        NegChipDefined,	"NegChipDefined",
        PositivePulse,	"PositivePulse",
        NegativePulse,	"NegativePulse",
        ToggledFromLow,	"ToggledFromLow",
        ToggledFromHigh,	"ToggledFromHigh"
};

int Type_OutSignalType::count = TYPE_OUTSIGNALTYPE;

char* Type_OutSignalType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_OutSignalType::count; ++i)
    {
        if (Type_OutSignalType::content[i].iID == id)
        {
            return Type_OutSignalType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_OutSignalType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_OutSignalType::count; ++i)
    {
        if (0 == strcmp(caption,Type_OutSignalType::content[i].strSpec))
        {
            return Type_OutSignalType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_CounterCapability::content[TYPE_COUNTCAPABILITY] = {
    Primary,	"Primary",
        InstantEventCount,	"InstantEventCount",
        OneShot,	"OneShot",
        TimerPulse,	"TimerPulse",
        InstantFreqMeter,	"InstantFreqMeter",
        InstantPwmIn,	"InstantPwmIn",
        InstantPwmOut,	"InstantPwmOut",
        UpDownCount,	"UpDownCount"
};

int Type_CounterCapability::count = TYPE_COUNTCAPABILITY;

char* Type_CounterCapability::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_CounterCapability::count; ++i)
    {
        if (Type_CounterCapability::content[i].iID == id)
        {
            return Type_CounterCapability::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_CounterCapability::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_CounterCapability::count; ++i)
    {
        if (0 == strcmp(caption,Type_CounterCapability::content[i].strSpec))
        {
            return Type_CounterCapability::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_CounterOperationMode::content[TYPE_CONTEROPERATIONMODE] = {
    C8254_M0,	"C8254_M0",
        C8254_M1,	"C8254_M1",
        C8254_M2,	"C8254_M2",
        C8254_M3,	"C8254_M3",
        C8254_M4,	"C8254_M4",
        C8254_M5,	"C8254_M5",
        C1780_MA,	"C1780_MA",
        C1780_MB,	"C1780_MB",
        C1780_MC,	"C1780_MC",
        C1780_MD,	"C1780_MD",
        C1780_ME,	"C1780_ME",
        C1780_MF,	"C1780_MF",
        C1780_MG,	"C1780_MG",
        C1780_MH,	"C1780_MH",
        C1780_MI,	"C1780_MI",
        C1780_MJ,	"C1780_MJ",
        C1780_MK,	"C1780_MK",
        C1780_ML,	"C1780_ML",
        C1780_MO,	"C1780_MO",
        C1780_MR,	"C1780_MR",
        C1780_MU,	"C1780_MU",
        C1780_MX,	"C1780_MX"
};

int Type_CounterOperationMode::count = TYPE_CONTEROPERATIONMODE;

char* Type_CounterOperationMode::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_CounterOperationMode::count; ++i)
    {
        if (Type_CounterOperationMode::content[i].iID == id)
        {
            return Type_CounterOperationMode::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_CounterOperationMode::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_CounterOperationMode::count; ++i)
    {
        if (0 == strcmp(caption,Type_CounterOperationMode::content[i].strSpec))
        {
            return Type_CounterOperationMode::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_CounterValueRegister::content[TYPE_COUNTERVALUREGISTER] = {
    CntLoad,	"CntLoad",
        CntPreset,	"CntPreset",
        CntHold,	"CntHold",
        CntOverCompare,	"CntOverCompare",
	CntUnderCompare,	"CntUnderCompare"
};

int Type_CounterValueRegister::count = TYPE_COUNTERVALUREGISTER;

char* Type_CounterValueRegister::GetPropertySpec(int id)
{
	for (int i = 0; i < Type_CounterValueRegister::count; ++i)
	{
		if (Type_CounterValueRegister::content[i].iID == id)
		{
			return Type_CounterValueRegister::content[i].strSpec;
		}
	}
	return "undefine ID";
}

int Type_CounterValueRegister::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_CounterValueRegister::count; ++i)
    {
        if (0 == strcmp(caption,Type_CounterValueRegister::content[i].strSpec))
        {
            return Type_CounterValueRegister::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_CounterCascadeGroup::content[TYPE_COUNTERCASCADEGROUP] = {
    GroupNone,	"GroupNone",
        Cnt0Cnt1,	"Cnt0Cnt1",
        Cnt2Cnt3,	"Cnt2Cnt3",
        Cnt4Cnt5,	"Cnt4Cnt5",
        Cnt6Cnt7,	"Cnt6Cnt7"
};

int Type_CounterCascadeGroup::count = TYPE_COUNTERCASCADEGROUP;

char* Type_CounterCascadeGroup::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_CounterCascadeGroup::count; ++i)
    {
        if (Type_CounterCascadeGroup::content[i].iID == id)
        {
            return Type_CounterCascadeGroup::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_CounterCascadeGroup::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_CounterCascadeGroup::count; ++i)
    {
        if (0 == strcmp(caption,Type_CounterCascadeGroup::content[i].strSpec))
        {
            return Type_CounterCascadeGroup::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_FreqMeasureMethod::content[TYPE_FREQMESUREMETHOD] = {
    AutoAdaptive,	"AutoAdaptive",
        CountingPulseBySysTime,	"CountingPulseBySysTime",
        CountingPulseByDevTime,	"CountingPulseByDevTime",
        PeriodInverse,	"PeriodInverse"
};

int Type_FreqMeasureMethod::count = TYPE_FREQMESUREMETHOD;

char* Type_FreqMeasureMethod::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_FreqMeasureMethod::count; ++i)
    {
        if (Type_FreqMeasureMethod::content[i].iID == id)
        {
            return Type_FreqMeasureMethod::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_FreqMeasureMethod::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_FreqMeasureMethod::count; ++i)
    {
        if (0 == strcmp(caption,Type_FreqMeasureMethod::content[i].strSpec))
        {
            return Type_FreqMeasureMethod::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_ActiveSignal::content[TYPE_ACTIVESIGNAL] = {
    ActiveNone,	"ActiveNone",
        RisingEdge,	"RisingEdge",
        FallingEdge,    "FallingEdge",
        BothEdge,	"BothEdge",
        HighLevel,	"HighLevel",
        LowLevel,	"LowLevel"
};

int Type_ActiveSignal::count = TYPE_ACTIVESIGNAL;

char* Type_ActiveSignal::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_ActiveSignal::count; ++i)
    {
        if (Type_ActiveSignal::content[i].iID == id)
        {
            return Type_ActiveSignal::content[i].strSpec;
        }
    }
    return "undefine ID";
}


int Type_ActiveSignal::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_ActiveSignal::count; ++i)
    {
        if (0 == strcmp(caption, Type_ActiveSignal::content[i].strSpec))
        {
            return Type_ActiveSignal::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_TriggerAction::content[TYPE_TRIGGERACTION] = {
    ActionNone,	"ActionNone",
        DelayToStart,	"DelayToStart",
        DelayToStop,	"DelayToStop"
};

int Type_TriggerAction::count = TYPE_TRIGGERACTION;

char* Type_TriggerAction::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_TriggerAction::count; ++i)
    {
        if (Type_TriggerAction::content[i].iID == id)
        {
            return Type_TriggerAction::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_TriggerAction::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_TriggerAction::count; ++i)
    {
        if (0 == strcmp(caption, Type_TriggerAction::content[i].strSpec))
        {
            return Type_TriggerAction::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_SignalPosition::content[TYPE_SIGNALPOSITION] = {
    InternalSig,	"InternalSig",
        OnConnector,    "OnConnector",
        OnAmsi,	"OnAmsi"
};

int Type_SignalPosition::count = TYPE_SIGNALPOSITION;

char* Type_SignalPosition::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_SignalPosition::count; ++i)
    {
        if (Type_SignalPosition::content[i].iID == id)
        {
            return Type_SignalPosition::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_SignalPosition::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_SignalPosition::count; ++i)
    {
        if (0 == strcmp(caption, Type_SignalPosition::content[i].strSpec))
        {
            return Type_SignalPosition::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_SignalDrop::content[TYPE_SIGNALDROP] = {
	SignalNone ,	"SignalNone",      /* No connection */

	/*Internal signal connector*/
	SigInternalClock,		"SigInternalClock",        /* Device built-in clock, If the device has several built-in clock, this represent the highest freq one. */
	SigInternal1KHz,		"SigInternal1KHz",         /* Device built-in clock, 1KHz */
	SigInternal10KHz,		"SigInternal10KHz",        /* Device built-in clock, 10KHz */
	SigInternal100KHz,		"SigInternal100KHz",       /* Device built-in clock, 100KHz */
	SigInternal1MHz,		"SigInternal1MHz",         /* Device built-in clock, 1MHz */
	SigInternal10MHz,		"SigInternal10MHz",        /* Device built-in clock, 10MHz */
	SigInternal20MHz,		"SigInternal20MHz",        /* Device built-in clock, 20MHz */
	SigInternal30MHz,		"SigInternal30MHz",        /* Device built-in clock, 30MHz */
	SigInternal40MHz,		"SigInternal40MHz",        /* Device built-in clock, 40MHz */
	SigInternal50MHz,		"SigInternal50MHz",        /* Device built-in clock, 50MHz */
	SigInternal60MHz,		"SigInternal60MHz",        /* Device built-in clock, 60MHz */

	SigDiPatternMatch,	"SigDiPatternMatch",       /* When DI pattern match occurred */
	SigDiStatusChange,	"SigDiStatusChange",       /* When DI status change occurred */

	/*Function pin on connector*/
	SigExtAnaClock,     	"SigExtAnaClock",     /* Analog clock pin of connector */
	SigExtAnaScanClock, 	"SigExtAnaScanClock",     /* scan clock pin of connector */
	SigExtAnaTrigger,   	"SigExtAnaTrigger",     /* external analog trigger pin of connector */
	SigExtDigClock,     	"SigExtDigClock",     /* digital clock pin of connector */
	SigExtDigTrigger0,  	"SigExtDigTrigger0",     /* external digital trigger 0 pin( or DI start trigger pin) of connector */
	SigExtDigTrigger1,  	"SigExtDigTrigger1",     /* external digital trigger 1 pin( or DI stop trigger pin) of connector  */
	SigExtDigTrigger2,  	"SigExtDigTrigger2",     /* external digital trigger 2 pin( or DO start trigger pin) of connector */
	SigExtDigTrigger3,  	"SigExtDigTrigger3",     /* external digital trigger 3 pin( or DO stop trigger pin) of connector  */
	SigCHFrzDo,         	"SigCHFrzDo",     /* Channel freeze DO ports pin */

	/*Signal source or target on the connector*/
	/*AI channel pins*/
	SigAi0,  	"SigAi0",	SigAi1,   	"SigAi1", SigAi2,	"SigAi2",SigAi3, 	"SigAi3",SigAi4,  	"SigAi4",SigAi5,  	"SigAi5",SigAi6,  	"SigAi6",SigAi7, 	"SigAi7",
	SigAi8,  	"SigAi8",	SigAi9,   	"SigAi9", SigAi10,	"SigAi10",SigAi11, 	"SigAi11",SigAi12, 	"SigAi12",SigAi13, 	"SigAi13",SigAi14, 	"SigAi14",SigAi15,	"SigAi15",
	SigAi16, 	"SigAi16",SigAi17, 	"SigAi17", SigAi18,	"SigAi18",SigAi19, 	"SigAi19",SigAi20, 	"SigAi20",SigAi21, 	"SigAi21",SigAi22, 	"SigAi22",SigAi23,	"SigAi23",
	SigAi24, 	"SigAi24",SigAi25, 	"SigAi25", SigAi26,	"SigAi26",SigAi27, 	"SigAi27",SigAi28, 	"SigAi28",SigAi29, 	"SigAi29",SigAi30, 	"SigAi30",SigAi31,	"SigAi31",
	SigAi32, 	"SigAi32",SigAi33, 	"SigAi33", SigAi34,	"SigAi34",SigAi35, 	"SigAi35",SigAi36, 	"SigAi36",SigAi37, 	"SigAi37",SigAi38, 	"SigAi38",SigAi39,	"SigAi39",
	SigAi40, 	"SigAi40",SigAi41, 	"SigAi41", SigAi42,	"SigAi42",SigAi43, 	"SigAi43",SigAi44, 	"SigAi44",SigAi45, 	"SigAi45",SigAi46, 	"SigAi46",SigAi47,	"SigAi47",
	SigAi48, 	"SigAi48",SigAi49, 	"SigAi49", SigAi50,	"SigAi50",SigAi51, 	"SigAi51",SigAi52, 	"SigAi52",SigAi53, 	"SigAi53",SigAi54, 	"SigAi54",SigAi55,	"SigAi55",
	SigAi56, 	"SigAi56",SigAi57, 	"SigAi57", SigAi58,	"SigAi58",SigAi59, 	"SigAi59",SigAi60, 	"SigAi60",SigAi61, 	"SigAi61",SigAi62, 	"SigAi62",SigAi63,	"SigAi63",

	/*AO channel pins*/
	SigAo0,	"SigAo0",SigAo1,  	"SigAo1",SigAo2,  	"SigAo2",SigAo3,  	"SigAo3",SigAo4,  	"SigAo4",SigAo5,  	"SigAo5",SigAo6,  	"SigAo6",SigAo7, 	"SigAo7",
	SigAo8,	"SigAo8",SigAo9,  	"SigAo9",SigAo10, 	"SigAo10",SigAo11, 	"SigAo11",SigAo12, 	"SigAo12",SigAo13, 	"SigAo13",SigAo14, 	"SigAo14",SigAo15,	"SigAo15",
	SigAo16,	"SigAo16",SigAo17, 	"SigAo17",SigAo18, 	"SigAo18",SigAo19, 	"SigAo19",SigAo20, 	"SigAo20",SigAo21, 	"SigAo21",SigAo22, 	"SigAo22",SigAo23,	"SigAo23",
	SigAo24,	"SigAo24",SigAo25, 	"SigAo25",SigAo26, 	"SigAo26",SigAo27, 	"SigAo27",SigAo28, 	"SigAo28",SigAo29, 	"SigAo29",SigAo30, 	"SigAo30",SigAo31,	"SigAo31",

	/*DI pins*/
	SigDi0,	"SigDi0",SigDi1,		"SigDi1",SigDi2,  	"SigDi2",SigDi3,  	"SigDi3",SigDi4,  	"SigDi4",SigDi5,  	"SigDi5",SigDi6,  	"SigDi6",SigDi7,		"SigDi7",
	SigDi8,	"SigDi8,",SigDi9,		"SigDi9,",SigDi10, 	"SigDi10",SigDi11, 	"SigDi11",SigDi12, 	"SigDi12",SigDi13, 	"SigDi13",SigDi14, 	"SigDi14",SigDi15,	    "SigDi15",
	SigDi16, 	"SigDi16",SigDi17,  	"SigDi17",SigDi18,  	"SigDi18",SigDi19,  	"SigDi19",SigDi20,  	"SigDi20",SigDi21,  	"SigDi21",SigDi22,  	"SigDi22",SigDi23,	"SigDi23",
	SigDi24, 	"SigDi24",SigDi25,  	"SigDi25",SigDi26,  	"SigDi26",SigDi27,  	"SigDi27",SigDi28,  	"SigDi28",SigDi29,  	"SigDi29",SigDi30,  	"SigDi30",SigDi31,	"SigDi31",
	SigDi32, 	"SigDi32",SigDi33,  	"SigDi33",SigDi34,  	"SigDi34",SigDi35,  	"SigDi35",SigDi36,  	"SigDi36",SigDi37,  	"SigDi37",SigDi38,  	"SigDi38",SigDi39,	"SigDi39",
	SigDi40, 	"SigDi40",SigDi41,  	"SigDi41",SigDi42,  	"SigDi42",SigDi43,  	"SigDi43",SigDi44,  	"SigDi44",SigDi45,  	"SigDi45",SigDi46,  	"SigDi46",SigDi47,	"SigDi47",
	SigDi48, 	"SigDi48",SigDi49,  	"SigDi49",SigDi50,  	"SigDi50",SigDi51,  	"SigDi51",SigDi52,  	"SigDi52",SigDi53,  	"SigDi53",SigDi54,  	"SigDi54",SigDi55,	"SigDi55",
	SigDi56, 	"SigDi56",SigDi57,  	"SigDi57",SigDi58,  	"SigDi58",SigDi59,  	"SigDi59",SigDi60,  	"SigDi60",SigDi61,  	"SigDi61",SigDi62,  	"SigDi62",SigDi63,	"SigDi63",
	SigDi64, 	"SigDi64",SigDi65,  	"SigDi65",SigDi66,  	"SigDi66",SigDi67,  	"SigDi67",SigDi68,  	"SigDi68",SigDi69,  	"SigDi69",SigDi70,  	"SigDi70",SigDi71,	"SigDi71",
	SigDi72, 	"SigDi72",SigDi73,  	"SigDi73",SigDi74,  	"SigDi74",SigDi75,  	"SigDi75",SigDi76,  	"SigDi76",SigDi77,  	"SigDi77",SigDi78,  	"SigDi78",SigDi79,	"SigDi79",
	SigDi80, 	"SigDi80",SigDi81,  	"SigDi81",SigDi82,  	"SigDi82",SigDi83,  	"SigDi83",SigDi84,  	"SigDi84",SigDi85,  	"SigDi85",SigDi86,  	"SigDi86",SigDi87,	"SigDi87",
	SigDi88, 	"SigDi88",SigDi89,  	"SigDi89",SigDi90,  	"SigDi90",SigDi91,  	"SigDi91",SigDi92,  	"SigDi92",SigDi93,  	"SigDi93",SigDi94,  	"SigDi94",SigDi95,	"SigDi95",
	SigDi96,  "SigDi96",SigDi97,	"SigDi97",SigDi98,	"SigDi98",SigDi99,	"SigDi99",SigDi100,   "SigDi100",SigDi101,  "SigDi101",SigDi102,	"SigDi102",SigDi103,	"SigDi103",
	SigDi112, "SigDi112",SigDi113,  "SigDi113",SigDi114,  "SigDi114",SigDi115,  "SigDi115",SigDi116,  "SigDi116",SigDi117,  "SigDi117",SigDi118,  "SigDi118",SigDi119,	"SigDi119",
	SigDi120, "SigDi120",SigDi121,  "SigDi121",SigDi122,  "SigDi122",SigDi123,  "SigDi123",SigDi124,  "SigDi124",SigDi125,  "SigDi125",SigDi126,  "SigDi126",SigDi127,	"SigDi127",
	SigDi128, "SigDi128",SigDi129,  "SigDi129",SigDi130,  "SigDi130",SigDi131,  "SigDi131",SigDi132,  "SigDi132",SigDi133,  "SigDi133",SigDi134,  "SigDi134",SigDi135,	"SigDi135",
	SigDi136, "SigDi136",SigDi137,  "SigDi137",SigDi138,  "SigDi138",SigDi139,  "SigDi139",SigDi140,  "SigDi140",SigDi141,  "SigDi141",SigDi142,  "SigDi142",SigDi143,	"SigDi143",
	SigDi144, "SigDi144",SigDi145,  "SigDi145",SigDi146,  "SigDi146",SigDi147,  "SigDi147",SigDi148,  "SigDi148",SigDi149,  "SigDi149",SigDi150,  "SigDi150",SigDi151,	"SigDi151",
	SigDi152, "SigDi152",SigDi153,  "SigDi153",SigDi154,  "SigDi154",SigDi155,  "SigDi155",SigDi156,  "SigDi156",SigDi157,  "SigDi157",SigDi158,  "SigDi158",SigDi159,	"SigDi159",
	SigDi160, "SigDi160",SigDi161,  "SigDi161",SigDi162,  "SigDi162",SigDi163,  "SigDi163",SigDi164,  "SigDi164",SigDi165,  "SigDi165",SigDi166,  "SigDi166",SigDi167,	"SigDi167",
	SigDi168, "SigDi168",SigDi169,  "SigDi169",SigDi170,  "SigDi170",SigDi171,  "SigDi171",SigDi172,  "SigDi172",SigDi173,  "SigDi173",SigDi174,  "SigDi174",SigDi175,	"SigDi175",
	SigDi176, "SigDi176",SigDi177,  "SigDi177",SigDi178,  "SigDi178",SigDi179,  "SigDi179",SigDi180,  "SigDi180",SigDi181,  "SigDi181",SigDi182,  "SigDi182",SigDi183,	"SigDi183",
	SigDi184, "SigDi184",SigDi185,  "SigDi185",SigDi186,  "SigDi186",SigDi187,  "SigDi187",SigDi188,  "SigDi188",SigDi189,  "SigDi189",SigDi190,  "SigDi190",SigDi191,	"SigDi191",
	SigDi192, "SigDi192",SigDi193,  "SigDi193",SigDi194,  "SigDi194",SigDi195,  "SigDi195",SigDi196,  "SigDi196",SigDi197,  "SigDi197",SigDi198,  "SigDi198",SigDi199,	"SigDi199",
	SigDi200, "SigDi200",SigDi201,  "SigDi201",SigDi202,  "SigDi202",SigDi203,  "SigDi203",SigDi204,  "SigDi204",SigDi205,  "SigDi205",SigDi206,  "SigDi206",SigDi207,	"SigDi207",
	SigDi208, "SigDi208",SigDi209,  "SigDi209",SigDi210,  "SigDi210",SigDi211,  "SigDi211",SigDi212,  "SigDi212",SigDi213,  "SigDi213",SigDi214,  "SigDi214",SigDi215,	"SigDi215",
	SigDi216, "SigDi216",SigDi217, 	"SigDi217",SigDi218,  "SigDi218",SigDi219, 	"SigDi219",SigDi220,  "SigDi220",SigDi221, 	"SigDi221",SigDi222,  "SigDi222",SigDi223,	"SigDi223",
	SigDi224, "SigDi224",SigDi225, 	"SigDi225",SigDi226,  "SigDi226",SigDi227, 	"SigDi227",SigDi228,  "SigDi228",SigDi229, 	"SigDi229",SigDi230,  "SigDi230",SigDi231,	"SigDi231",
	SigDi232, "SigDi232",SigDi233,  "SigDi233",SigDi234,  "SigDi234",SigDi235,  "SigDi235",SigDi236,  "SigDi236",SigDi237,  "SigDi237",SigDi238,  "SigDi238",SigDi239,	"SigDi239",
	SigDi240, "SigDi240",SigDi241,  "SigDi241",SigDi242,  "SigDi242",SigDi243,  "SigDi243",SigDi244,  "SigDi244",SigDi245,  "SigDi245",SigDi246,  "SigDi246",SigDi247,	"SigDi247",
	SigDi248, "SigDi248",SigDi249, 	"SigDi249",SigDi250,  "SigDi250",SigDi251, 	"SigDi251",SigDi252,  "SigDi252",SigDi253, 	"SigDi253",SigDi254,  "SigDi254",SigDi255,	"SigDi255",

	/*DIO pins*/
	SigDio0,  	"SigDio0",SigDio1,  	"SigDio1",SigDio2,  	"SigDio2",SigDio3,  	"SigDio3",SigDio4,  	"SigDio4",SigDio5,  	"SigDio5",SigDio6,  	"SigDio6",SigDio7,	"SigDio7",
	SigDio8,  	"SigDio8",SigDio9,  	"SigDio9",SigDio10, 	"SigDio10",SigDio11, 	"SigDio11",SigDio12, 	"SigDio12",SigDio13, 	"SigDio13",SigDio14, 	"SigDio14",SigDio15,	"SigDio15",
	SigDio16, 	"SigDio16",SigDio17, 	"SigDio17",SigDio18, 	"SigDio18",SigDio19, 	"SigDio19",SigDio20, 	"SigDio20",SigDio21, 	"SigDio21",SigDio22, 	"SigDio22",SigDio23,	"SigDio23",
	SigDio24, 	"SigDio24",SigDio25, 	"SigDio25",SigDio26, 	"SigDio26",SigDio27, 	"SigDio27",SigDio28, 	"SigDio28",SigDio29, 	"SigDio29",SigDio30, 	"SigDio30",SigDio31,	"SigDio31",
	SigDio32, 	"SigDio32",SigDio33, 	"SigDio33",SigDio34, 	"SigDio34",SigDio35, 	"SigDio35",SigDio36, 	"SigDio36",SigDio37, 	"SigDio37",SigDio38, 	"SigDio38",SigDio39,	"SigDio39",
	SigDio40, 	"SigDio40",SigDio41, 	"SigDio41",SigDio42, 	"SigDio42",SigDio43, 	"SigDio43",SigDio44, 	"SigDio44",SigDio45, 	"SigDio45",SigDio46, 	"SigDio46",SigDio47,	"SigDio47",
	SigDio48, 	"SigDio48",SigDio49, 	"SigDio49",SigDio50, 	"SigDio50",SigDio51, 	"SigDio51",SigDio52, 	"SigDio52",SigDio53, 	"SigDio53",SigDio54, 	"SigDio54",SigDio55,	"SigDio55",
	SigDio56, 	"SigDio56",SigDio57, 	"SigDio57",SigDio58, 	"SigDio58",SigDio59, 	"SigDio59",SigDio60, 	"SigDio60",SigDio61, 	"SigDio61",SigDio62, 	"SigDio62",SigDio63,	"SigDio63",
	SigDio64, 	"SigDio64",SigDio65, 	"SigDio65",SigDio66, 	"SigDio66",SigDio67, 	"SigDio67",SigDio68, 	"SigDio68",SigDio69, 	"SigDio69",SigDio70, 	"SigDio70",SigDio71,	"SigDio71",
	SigDio72, 	"SigDio72",SigDio73, 	"SigDio73",SigDio74, 	"SigDio74",SigDio75, 	"SigDio75",SigDio76, 	"SigDio76",SigDio77, 	"SigDio77",SigDio78, 	"SigDio78",SigDio79,	"SigDio79",
	SigDio80, 	"SigDio80",SigDio81, 	"SigDio81",SigDio82, 	"SigDio82",SigDio83, 	"SigDio83",SigDio84, 	"SigDio84",SigDio85, 	"SigDio85",SigDio86, 	"SigDio86",SigDio87,	"SigDio87",
	SigDio88, 	"SigDio88",SigDio89, 	"SigDio89",SigDio90, 	"SigDio90",SigDio91, 	"SigDio91",SigDio92, 	"SigDio92",SigDio93, 	"SigDio93",SigDio94, 	"SigDio94",SigDio95,	"SigDio95",
	SigDio96, 	"SigDio96",SigDio97, 	"SigDio97",SigDio98, 	"SigDio98",SigDio99, 	"SigDio99",SigDio100,	"SigDio100",SigDio101,	"SigDio101",SigDio102,	"SigDio102",SigDio103,	"SigDio103",
	SigDio104,	"SigDio104",SigDio105, 	"SigDio105",SigDio106, 	"SigDio106",SigDio107, 	"SigDio107",SigDio108, 	"SigDio108",SigDio109, 	"SigDio109",SigDio110, 	"SigDio110",SigDio111, 	"SigDio111",
	SigDio112,	"SigDio112",SigDio113, 	"SigDio113",SigDio114, 	"SigDio114",SigDio115, 	"SigDio115",SigDio116, 	"SigDio116",SigDio117, 	"SigDio117",SigDio118, 	"SigDio118",SigDio119,	"SigDio119",
	SigDio120,	"SigDio120",SigDio121, 	"SigDio121",SigDio122, 	"SigDio122",SigDio123, 	"SigDio123",SigDio124, 	"SigDio124",SigDio125, 	"SigDio125",SigDio126, 	"SigDio126",SigDio127,	"SigDio127",
    SigDio128, 	"SigDio128",SigDio129,  	"SigDio129",SigDio130,  	"SigDio130",SigDio131,  	"SigDio131",SigDio132,  	"SigDio132",SigDio133,  	"SigDio133",SigDio134,  	"SigDio134",SigDio135,	"SigDio135",
    SigDio136, 	"SigDio136",SigDio137,  	"SigDio137",SigDio138,  	"SigDio138",SigDio139,  	"SigDio139",SigDio140,  	"SigDio140",SigDio141,  	"SigDio141",SigDio142,  	"SigDio142",SigDio143,	"SigDio143",
    SigDio144, 	"SigDio144",SigDio145,  	"SigDio145",SigDio146,  	"SigDio146",SigDio147,  	"SigDio147",SigDio148,  	"SigDio148",SigDio149,  	"SigDio149",SigDio150,  	"SigDio150",SigDio151,	"SigDio151",
    SigDio152, 	"SigDio152",SigDio153,  	"SigDio153",SigDio154,  	"SigDio154",SigDio155,  	"SigDio155",SigDio156,  	"SigDio156",SigDio157,  	"SigDio157",SigDio158,  	"SigDio158",SigDio159,	"SigDio159",
    SigDio160, 	"SigDio160",SigDio161,  	"SigDio161",SigDio162,  	"SigDio162",SigDio163,  	"SigDio163",SigDio164,  	"SigDio164",SigDio165,  	"SigDio165",SigDio166,  	"SigDio166",SigDio167,	"SigDio167",
    SigDio168, 	"SigDio168",SigDio169,  	"SigDio169",SigDio170,  	"SigDio170",SigDio171,  	"SigDio171",SigDio172,  	"SigDio172",SigDio173,  	"SigDio173",SigDio174,  	"SigDio174",SigDio175,	"SigDio175",
    SigDio176, 	"SigDio176",SigDio177,  	"SigDio177",SigDio178,  	"SigDio178",SigDio179,  	"SigDio179",SigDio180,  	"SigDio180",SigDio181,  	"SigDio181",SigDio182,  	"SigDio182",SigDio183,	"SigDio183",
	SigDio184, 	"SigDio184",SigDio185,  	"SigDio185",SigDio186,  	"SigDio186",SigDio187,  	"SigDio187",SigDio188,  	"SigDio188",SigDio189,  	"SigDio189",SigDio190,  	"SigDio190",SigDio191,	"SigDio191",
	SigDio192, 	"SigDio192",SigDio193,  	"SigDio193",SigDio194,  	"SigDio194",SigDio195,  	"SigDio195",SigDio196,  	"SigDio196",SigDio197,  	"SigDio197",SigDio198,  	"SigDio198",SigDio199,	"SigDio199",
	SigDio200, 	"SigDio200",SigDio201,  	"SigDio201",SigDio202,  	"SigDio202",SigDio203,  	"SigDio203",SigDio204,  	"SigDio204",SigDio205,  	"SigDio205",SigDio206,  	"SigDio206",SigDio207,	"SigDio207",
	SigDio208, 	"SigDio208",SigDio209,  	"SigDio209",SigDio210,  	"SigDio210",SigDio211,  	"SigDio211",SigDio212,  	"SigDio212",SigDio213,  	"SigDio213",SigDio214,  	"SigDio214",SigDio215,	"SigDio215",
	SigDio216, 	"SigDio216",SigDio217,  	"SigDio217",SigDio218,  	"SigDio218",SigDio219,  	"SigDio219",SigDio220,  	"SigDio220",SigDio221,  	"SigDio221",SigDio222,  	"SigDio222",SigDio223,	"SigDio223",
	SigDio224, 	"SigDio224",SigDio225,  	"SigDio225",SigDio226,  	"SigDio226",SigDio227,  	"SigDio227",SigDio228,  	"SigDio228",SigDio229,  	"SigDio229",SigDio230,  	"SigDio230",SigDio231,	"SigDio231",
	SigDio232, 	"SigDio232",SigDio233,  	"SigDio233",SigDio234,  	"SigDio234",SigDio235,  	"SigDio235",SigDio236,  	"SigDio236",SigDio237,  	"SigDio237",SigDio238,  	"SigDio238",SigDio239,	"SigDio239",
	SigDio240, 	"SigDio240",SigDio241,  	"SigDio241",SigDio242,  	"SigDio242",SigDio243,  	"SigDio243",SigDio244,  	"SigDio244",SigDio245,  	"SigDio245",SigDio246,  	"SigDio246",SigDio247,	"SigDio247",
	SigDio248, 	"SigDio248",SigDio249,  	"SigDio249",SigDio250,  	"SigDio250",SigDio251,  	"SigDio251",SigDio252,  	"SigDio252",SigDio253,  	"SigDio253",SigDio254,  	"SigDio254",SigDio255,	"SigDio255",

	/*Counter clock pins*/
	SigCntClk0, 	"SigCntClk0", 
	SigCntClk1, 	"SigCntClk1", 
	SigCntClk2, 	"SigCntClk2", 
	SigCntClk3, 	"SigCntClk3", 
	SigCntClk4, 	"SigCntClk4", 
	SigCntClk5, 	"SigCntClk5", 
	SigCntClk6, 	"SigCntClk6", 
	SigCntClk7, 	"SigCntClk7",

	/*counter gate pins*/
	SigCntGate0, 	"SigCntGate0", 
	SigCntGate1, 	"SigCntGate1", 
	SigCntGate2, 	"SigCntGate2", 
	SigCntGate3, 	"SigCntGate3", 
	SigCntGate4, 	"SigCntGate4", 
	SigCntGate5, 	"SigCntGate5", 
	SigCntGate6, 	"SigCntGate6", 
	SigCntGate7, 	"SigCntGate7",

	/*counter out pins*/
	SigCntOut0, 	"SigCntOut0", 
	SigCntOut1, 	"SigCntOut1", 
	SigCntOut2, 	"SigCntOut2", 
	SigCntOut3, 	"SigCntOut3", 
	SigCntOut4, 	"SigCntOut4", 
	SigCntOut5, 	"SigCntOut5", 
	SigCntOut6, 	"SigCntOut6", 
	SigCntOut7, 	"SigCntOut7",

	/*counter frequency out pins*/
	SigCntFout0, 	"SigCntFout0", 
	SigCntFout1, 	"SigCntFout1", 
	SigCntFout2, 	"SigCntFout2", 
	SigCntFout3, 	"SigCntFout3", 
	SigCntFout4, 	"SigCntFout4", 
	SigCntFout5, 	"SigCntFout5", 
	SigCntFout6, 	"SigCntFout6", 
	SigCntFout7, 	"SigCntFout7",

	/*AMSI pins*/
	SigAmsiPin0, 	"SigAmsiPin0", 
	SigAmsiPin1, 	"SigAmsiPin1", 
	SigAmsiPin2, 	"SigAmsiPin2", 
	SigAmsiPin3, 	"SigAmsiPin3", 
	SigAmsiPin4, 	"SigAmsiPin4", 
	SigAmsiPin5, 	"SigAmsiPin5", 
	SigAmsiPin6, 	"SigAmsiPin6", 
	SigAmsiPin7, 	"SigAmsiPin7",
	SigAmsiPin8,  "SigAmsiPin8",
	SigAmsiPin9,  "SigAmsiPin9",
	SigAmsiPin10,	"SigAmsiPin10", 
	SigAmsiPin11,	"SigAmsiPin11", 
	SigAmsiPin12,	"SigAmsiPin12", 
	SigAmsiPin13,	"SigAmsiPin13", 
	SigAmsiPin14,	"SigAmsiPin14", 
	SigAmsiPin15,	"SigAmsiPin15",
	SigAmsiPin16,	"SigAmsiPin16",  
	SigAmsiPin17,	"SigAmsiPin17",  
	SigAmsiPin18,	"SigAmsiPin18",  
	SigAmsiPin19,	"SigAmsiPin19",

	/*new clocks*/
	SigInternal2Hz,		"SigInternal2Hz",         /* Device built-in clock, 2Hz */
	SigInternal20Hz,		"SigInternal20Hz",         /* Device built-in clock, 20Hz */
	SigInternal200Hz,		"SigInternal200Hz",        /* Device built-in clock, 200KHz */
	SigInternal2KHz,		"SigInternal2KHz",         /* Device built-in clock, 2KHz */
	SigInternal20KHz,		"SigInternal20KHz",        /* Device built-in clock, 20KHz */
	SigInternal200KHz,	"SigInternal200KHz",       /* Device built-in clock, 200KHz */
	SigInternal2MHz,		"SigInternal2MHz"         /* Device built-in clock, 2MHz */
};

int Type_SignalDrop::count = TYPE_SIGNALDROP;

char* Type_SignalDrop::GetPropertySpec(int id)
{
	for (int i = 0; i < Type_SignalDrop::count; ++i)
	{
		if (Type_SignalDrop::content[i].iID == id)
		{
			return Type_SignalDrop::content[i].strSpec;
		}
	}
	return "undefine ID";
}

int Type_SignalDrop::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_SignalDrop::count; ++i)
    {
        if (0 == strcmp(caption, Type_SignalDrop::content[i].strSpec))
        {
            return Type_SignalDrop::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_EventId::content[TYPE_EVENTID] = {
	EvtDeviceRemoved ,	"EvtDeviceRemoved",/* The device was removed from system */
	EvtDeviceReconnected,	"EvtDeviceReconnected",  /* The device is reconnected */
	EvtPropertyChanged,	"EvtPropertyChanged",    /* Some properties of the device were changed */
	/*-----------------------------------------------------------------
	* AI events
	*-----------------------------------------------------------------*/
	EvtBufferedAiDataReady,		"EvtBufferedAiDataReady",
	EvtBufferedAiOverrun,			"EvtBufferedAiOverrun",
	EvtBufferedAiCacheOverflow,	"EvtBufferedAiCacheOverflow",
	EvtBufferedAiStopped,			"EvtBufferedAiStopped",

	/*-----------------------------------------------------------------
	* AO event IDs
	*-----------------------------------------------------------------*/
	EvtBufferedAoDataTransmitted,	"EvtBufferedAoDataTransmitted",
	EvtBufferedAoUnderrun,		"EvtBufferedAoUnderrun",
	EvtBufferedAoCacheEmptied,	"EvtBufferedAoCacheEmptied",
	EvtBufferedAoTransStopped,	"EvtBufferedAoTransStopped",
	EvtBufferedAoStopped,			"EvtBufferedAoStopped",

	/*-----------------------------------------------------------------
	* DIO event IDs
	*-----------------------------------------------------------------*/
	EvtDiintChannel000,	"EvtDiintChannel000",EvtDiintChannel001, 	"EvtDiintChannel001",EvtDiintChannel002, 	"EvtDiintChannel002",EvtDiintChannel003,	"EvtDiintChannel003",
	EvtDiintChannel004,	"EvtDiintChannel004",EvtDiintChannel005, 	"EvtDiintChannel005",EvtDiintChannel006, 	"EvtDiintChannel006",EvtDiintChannel007,	"EvtDiintChannel007",
	EvtDiintChannel008,	"EvtDiintChannel008",EvtDiintChannel009, 	"EvtDiintChannel009",EvtDiintChannel010, 	"EvtDiintChannel010",EvtDiintChannel011,	"EvtDiintChannel011",
	EvtDiintChannel012,	"EvtDiintChannel012",EvtDiintChannel013, 	"EvtDiintChannel013",EvtDiintChannel014, 	"EvtDiintChannel014",EvtDiintChannel015,	"EvtDiintChannel015",
	EvtDiintChannel016,	"EvtDiintChannel016",EvtDiintChannel017, 	"EvtDiintChannel017",EvtDiintChannel018, 	"EvtDiintChannel018",EvtDiintChannel019,	"EvtDiintChannel019",
	EvtDiintChannel020,	"EvtDiintChannel020",EvtDiintChannel021, 	"EvtDiintChannel021",EvtDiintChannel022, 	"EvtDiintChannel022",EvtDiintChannel023,	"EvtDiintChannel023",
	EvtDiintChannel024,	"EvtDiintChannel024",EvtDiintChannel025, 	"EvtDiintChannel025",EvtDiintChannel026, 	"EvtDiintChannel026",EvtDiintChannel027,	"EvtDiintChannel027",
	EvtDiintChannel028,	"EvtDiintChannel028",EvtDiintChannel029, 	"EvtDiintChannel029",EvtDiintChannel030, 	"EvtDiintChannel030",EvtDiintChannel031,	"EvtDiintChannel031",
	EvtDiintChannel032,	"EvtDiintChannel032",EvtDiintChannel033, 	"EvtDiintChannel033",EvtDiintChannel034, 	"EvtDiintChannel034",EvtDiintChannel035,	"EvtDiintChannel035",
	EvtDiintChannel036,	"EvtDiintChannel036",EvtDiintChannel037, 	"EvtDiintChannel037",EvtDiintChannel038, 	"EvtDiintChannel038",EvtDiintChannel039,	"EvtDiintChannel039",
	EvtDiintChannel040,	"EvtDiintChannel040",EvtDiintChannel041, 	"EvtDiintChannel041",EvtDiintChannel042, 	"EvtDiintChannel042",EvtDiintChannel043,	"EvtDiintChannel043",
	EvtDiintChannel044,	"EvtDiintChannel044",EvtDiintChannel045, 	"EvtDiintChannel045",EvtDiintChannel046, 	"EvtDiintChannel046",EvtDiintChannel047,	"EvtDiintChannel047",
	EvtDiintChannel048,	"EvtDiintChannel048",EvtDiintChannel049, 	"EvtDiintChannel049",EvtDiintChannel050, 	"EvtDiintChannel050",EvtDiintChannel051,	"EvtDiintChannel051",
	EvtDiintChannel052,	"EvtDiintChannel052",EvtDiintChannel053, 	"EvtDiintChannel053",EvtDiintChannel054, 	"EvtDiintChannel054",EvtDiintChannel055,	"EvtDiintChannel055",
	EvtDiintChannel056,	"EvtDiintChannel056",EvtDiintChannel057, 	"EvtDiintChannel057",EvtDiintChannel058, 	"EvtDiintChannel058",EvtDiintChannel059,	"EvtDiintChannel059",
	EvtDiintChannel060,	"EvtDiintChannel060",EvtDiintChannel061, 	"EvtDiintChannel061",EvtDiintChannel062, 	"EvtDiintChannel062",EvtDiintChannel063,	"EvtDiintChannel063",
	EvtDiintChannel064,	"EvtDiintChannel064",EvtDiintChannel065, 	"EvtDiintChannel065",EvtDiintChannel066, 	"EvtDiintChannel066",EvtDiintChannel067,	"EvtDiintChannel067",
	EvtDiintChannel068,	"EvtDiintChannel068",EvtDiintChannel069, 	"EvtDiintChannel069",EvtDiintChannel070, 	"EvtDiintChannel070",EvtDiintChannel071,	"EvtDiintChannel071",
	EvtDiintChannel072,	"EvtDiintChannel072",EvtDiintChannel073, 	"EvtDiintChannel073",EvtDiintChannel074, 	"EvtDiintChannel074",EvtDiintChannel075,	"EvtDiintChannel075",
	EvtDiintChannel076,	"EvtDiintChannel076",EvtDiintChannel077, 	"EvtDiintChannel077",EvtDiintChannel078, 	"EvtDiintChannel078",EvtDiintChannel079,	"EvtDiintChannel079",
	EvtDiintChannel080, 	"EvtDiintChannel080",EvtDiintChannel081, 	"EvtDiintChannel081",EvtDiintChannel082, 	"EvtDiintChannel082",EvtDiintChannel083,	"EvtDiintChannel083",
	EvtDiintChannel084, 	"EvtDiintChannel084",EvtDiintChannel085, 	"EvtDiintChannel085",EvtDiintChannel086, 	"EvtDiintChannel086",EvtDiintChannel087,	"EvtDiintChannel087",
	EvtDiintChannel088, 	"EvtDiintChannel088",EvtDiintChannel089, 	"EvtDiintChannel089",EvtDiintChannel090, 	"EvtDiintChannel090",EvtDiintChannel091,	"EvtDiintChannel091",
	EvtDiintChannel092, 	"EvtDiintChannel092",EvtDiintChannel093, 	"EvtDiintChannel093",EvtDiintChannel094, 	"EvtDiintChannel094",EvtDiintChannel095,	"EvtDiintChannel095",
	EvtDiintChannel096, 	"EvtDiintChannel096",EvtDiintChannel097, 	"EvtDiintChannel097",EvtDiintChannel098, 	"EvtDiintChannel098",EvtDiintChannel099,	"EvtDiintChannel099",
	EvtDiintChannel100, 	"EvtDiintChannel100",EvtDiintChannel101, 	"EvtDiintChannel101",EvtDiintChannel102, 	"EvtDiintChannel102",EvtDiintChannel103,	"EvtDiintChannel103",
	EvtDiintChannel104, 	"EvtDiintChannel104",EvtDiintChannel105, 	"EvtDiintChannel105",EvtDiintChannel106, 	"EvtDiintChannel106",EvtDiintChannel107,	"EvtDiintChannel107",
	EvtDiintChannel108, 	"EvtDiintChannel108",EvtDiintChannel109, 	"EvtDiintChannel109",EvtDiintChannel110, 	"EvtDiintChannel110",EvtDiintChannel111,	"EvtDiintChannel111",
	EvtDiintChannel112, 	"EvtDiintChannel112",EvtDiintChannel113, 	"EvtDiintChannel113",EvtDiintChannel114, 	"EvtDiintChannel114",EvtDiintChannel115,	"EvtDiintChannel115",
	EvtDiintChannel116, 	"EvtDiintChannel116",EvtDiintChannel117, 	"EvtDiintChannel117",EvtDiintChannel118, 	"EvtDiintChannel118",EvtDiintChannel119,	"EvtDiintChannel119",
	EvtDiintChannel120, 	"EvtDiintChannel120",EvtDiintChannel121, 	"EvtDiintChannel121",EvtDiintChannel122, 	"EvtDiintChannel122",EvtDiintChannel123,	"EvtDiintChannel123",
	EvtDiintChannel124, 	"EvtDiintChannel124",EvtDiintChannel125, 	"EvtDiintChannel125",EvtDiintChannel126, 	"EvtDiintChannel126",EvtDiintChannel127,	"EvtDiintChannel127",
	EvtDiintChannel128, 	"EvtDiintChannel128",EvtDiintChannel129, 	"EvtDiintChannel129",EvtDiintChannel130, 	"EvtDiintChannel130",EvtDiintChannel131,	"EvtDiintChannel131",
	EvtDiintChannel132, 	"EvtDiintChannel132",EvtDiintChannel133, 	"EvtDiintChannel133",EvtDiintChannel134, 	"EvtDiintChannel134",EvtDiintChannel135,	"EvtDiintChannel135",
	EvtDiintChannel136, 	"EvtDiintChannel136",EvtDiintChannel137, 	"EvtDiintChannel137",EvtDiintChannel138, 	"EvtDiintChannel138",EvtDiintChannel139,	"EvtDiintChannel139",
	EvtDiintChannel140, 	"EvtDiintChannel140",EvtDiintChannel141, 	"EvtDiintChannel141",EvtDiintChannel142, 	"EvtDiintChannel142",EvtDiintChannel143,	"EvtDiintChannel143",
	EvtDiintChannel144, 	"EvtDiintChannel144",EvtDiintChannel145, 	"EvtDiintChannel145",EvtDiintChannel146, 	"EvtDiintChannel146",EvtDiintChannel147,	"EvtDiintChannel147",
	EvtDiintChannel148, 	"EvtDiintChannel148",EvtDiintChannel149, 	"EvtDiintChannel149",EvtDiintChannel150, 	"EvtDiintChannel150",EvtDiintChannel151,	"EvtDiintChannel151",
	EvtDiintChannel152, 	"EvtDiintChannel152",EvtDiintChannel153, 	"EvtDiintChannel153",EvtDiintChannel154, 	"EvtDiintChannel154",EvtDiintChannel155,	"EvtDiintChannel155",
	EvtDiintChannel156, 	"EvtDiintChannel156",EvtDiintChannel157, 	"EvtDiintChannel157",EvtDiintChannel158, 	"EvtDiintChannel158",EvtDiintChannel159,	"EvtDiintChannel159",
	EvtDiintChannel160, 	"EvtDiintChannel160",EvtDiintChannel161, 	"EvtDiintChannel161",EvtDiintChannel162, 	"EvtDiintChannel162",EvtDiintChannel163,	"EvtDiintChannel163",
	EvtDiintChannel164, 	"EvtDiintChannel164",EvtDiintChannel165, 	"EvtDiintChannel165",EvtDiintChannel166, 	"EvtDiintChannel166",EvtDiintChannel167,	"EvtDiintChannel167",
	EvtDiintChannel168, 	"EvtDiintChannel168",EvtDiintChannel169, 	"EvtDiintChannel169",EvtDiintChannel170, 	"EvtDiintChannel170",EvtDiintChannel171,	"EvtDiintChannel171",
	EvtDiintChannel172, 	"EvtDiintChannel172",EvtDiintChannel173, 	"EvtDiintChannel173",EvtDiintChannel174, 	"EvtDiintChannel174",EvtDiintChannel175,	"EvtDiintChannel175",
	EvtDiintChannel176, 	"EvtDiintChannel176",EvtDiintChannel177, 	"EvtDiintChannel177",EvtDiintChannel178, 	"EvtDiintChannel178",EvtDiintChannel179,	"EvtDiintChannel179",
	EvtDiintChannel180, 	"EvtDiintChannel180",EvtDiintChannel181, 	"EvtDiintChannel181",EvtDiintChannel182, 	"EvtDiintChannel182",EvtDiintChannel183,	"EvtDiintChannel183",
	EvtDiintChannel184, 	"EvtDiintChannel184",EvtDiintChannel185, 	"EvtDiintChannel185",EvtDiintChannel186, 	"EvtDiintChannel186",EvtDiintChannel187,	"EvtDiintChannel187",
	EvtDiintChannel188, 	"EvtDiintChannel188",EvtDiintChannel189, 	"EvtDiintChannel189",EvtDiintChannel190, 	"EvtDiintChannel190",EvtDiintChannel191,	"EvtDiintChannel191",
	EvtDiintChannel192, 	"EvtDiintChannel192",EvtDiintChannel193, 	"EvtDiintChannel193",EvtDiintChannel194, 	"EvtDiintChannel194",EvtDiintChannel195,	"EvtDiintChannel195",
	EvtDiintChannel196, 	"EvtDiintChannel196",EvtDiintChannel197, 	"EvtDiintChannel197",EvtDiintChannel198, 	"EvtDiintChannel198",EvtDiintChannel199,	"EvtDiintChannel199",
	EvtDiintChannel200, 	"EvtDiintChannel200",EvtDiintChannel201, 	"EvtDiintChannel201",EvtDiintChannel202, 	"EvtDiintChannel202",EvtDiintChannel203,	"EvtDiintChannel203",
	EvtDiintChannel204, 	"EvtDiintChannel204",EvtDiintChannel205, 	"EvtDiintChannel205",EvtDiintChannel206, 	"EvtDiintChannel206",EvtDiintChannel207,	"EvtDiintChannel207",
	EvtDiintChannel208, 	"EvtDiintChannel208",EvtDiintChannel209, 	"EvtDiintChannel209",EvtDiintChannel210, 	"EvtDiintChannel210",EvtDiintChannel211,	"EvtDiintChannel211",
	EvtDiintChannel212, 	"EvtDiintChannel212",EvtDiintChannel213, 	"EvtDiintChannel213",EvtDiintChannel214, 	"EvtDiintChannel214",EvtDiintChannel215,	"EvtDiintChannel215",
	EvtDiintChannel216, 	"EvtDiintChannel216",EvtDiintChannel217, 	"EvtDiintChannel217",EvtDiintChannel218, 	"EvtDiintChannel218",EvtDiintChannel219,	"EvtDiintChannel219",
	EvtDiintChannel220, 	"EvtDiintChannel220",EvtDiintChannel221, 	"EvtDiintChannel221",EvtDiintChannel222, 	"EvtDiintChannel222",EvtDiintChannel223,	"EvtDiintChannel223",
	EvtDiintChannel224, 	"EvtDiintChannel224",EvtDiintChannel225, 	"EvtDiintChannel225",EvtDiintChannel226, 	"EvtDiintChannel226",EvtDiintChannel227,	"EvtDiintChannel227",
	EvtDiintChannel228, 	"EvtDiintChannel228",EvtDiintChannel229, 	"EvtDiintChannel229",EvtDiintChannel230, 	"EvtDiintChannel230",EvtDiintChannel231,	"EvtDiintChannel231",
	EvtDiintChannel232, 	"EvtDiintChannel232",EvtDiintChannel233, 	"EvtDiintChannel233",EvtDiintChannel234, 	"EvtDiintChannel234",EvtDiintChannel235,	"EvtDiintChannel235",
	EvtDiintChannel236, 	"EvtDiintChannel236",EvtDiintChannel237, 	"EvtDiintChannel237",EvtDiintChannel238, 	"EvtDiintChannel238",EvtDiintChannel239,	"EvtDiintChannel239",
	EvtDiintChannel240, 	"EvtDiintChannel240",EvtDiintChannel241, 	"EvtDiintChannel241",EvtDiintChannel242, 	"EvtDiintChannel242",EvtDiintChannel243,	"EvtDiintChannel243",
	EvtDiintChannel244, 	"EvtDiintChannel244",EvtDiintChannel245, 	"EvtDiintChannel245",EvtDiintChannel246, 	"EvtDiintChannel246",EvtDiintChannel247,	"EvtDiintChannel247",
	EvtDiintChannel248, 	"EvtDiintChannel248",EvtDiintChannel249, 	"EvtDiintChannel249",EvtDiintChannel250, 	"EvtDiintChannel250",EvtDiintChannel251,	"EvtDiintChannel251",
	EvtDiintChannel252, 	"EvtDiintChannel252",EvtDiintChannel253, 	"EvtDiintChannel253",EvtDiintChannel254, 	"EvtDiintChannel254",EvtDiintChannel255,	"EvtDiintChannel255",

	EvtDiCosintPort000, 	"EvtDiCosintPort000",EvtDiCosintPort001, 	"EvtDiCosintPort001",EvtDiCosintPort002, 	"EvtDiCosintPort002",EvtDiCosintPort003,	"EvtDiCosintPort003",
	EvtDiCosintPort004, 	"EvtDiCosintPort004",EvtDiCosintPort005, 	"EvtDiCosintPort005",EvtDiCosintPort006, 	"EvtDiCosintPort006",EvtDiCosintPort007,	"EvtDiCosintPort007",
	EvtDiCosintPort008, 	"EvtDiCosintPort008",EvtDiCosintPort009, 	"EvtDiCosintPort009",EvtDiCosintPort010, 	"EvtDiCosintPort010",EvtDiCosintPort011,	"EvtDiCosintPort011",
	EvtDiCosintPort012, 	"EvtDiCosintPort012",EvtDiCosintPort013, 	"EvtDiCosintPort013",EvtDiCosintPort014, 	"EvtDiCosintPort014",EvtDiCosintPort015,	"EvtDiCosintPort015",
	EvtDiCosintPort016, 	"EvtDiCosintPort016",EvtDiCosintPort017, 	"EvtDiCosintPort017",EvtDiCosintPort018, 	"EvtDiCosintPort018",EvtDiCosintPort019,	"EvtDiCosintPort019",
	EvtDiCosintPort020, 	"EvtDiCosintPort020",EvtDiCosintPort021, 	"EvtDiCosintPort021",EvtDiCosintPort022, 	"EvtDiCosintPort022",EvtDiCosintPort023,	"EvtDiCosintPort023",
	EvtDiCosintPort024, 	"EvtDiCosintPort024",EvtDiCosintPort025, 	"EvtDiCosintPort025",EvtDiCosintPort026, 	"EvtDiCosintPort026",EvtDiCosintPort027,	"EvtDiCosintPort027",
	EvtDiCosintPort028, 	"EvtDiCosintPort028",EvtDiCosintPort029, 	"EvtDiCosintPort029",EvtDiCosintPort030, 	"EvtDiCosintPort030",EvtDiCosintPort031,	"EvtDiCosintPort031",

	EvtDiPmintPort000, 	"EvtDiPmintPort000",EvtDiPmintPort001, 	"EvtDiPmintPort001",EvtDiPmintPort002, 	"EvtDiPmintPort002",EvtDiPmintPort003,	"EvtDiPmintPort003",
	EvtDiPmintPort004, 	"EvtDiPmintPort004",EvtDiPmintPort005, 	"EvtDiPmintPort005",EvtDiPmintPort006, 	"EvtDiPmintPort006",EvtDiPmintPort007,	"EvtDiPmintPort007",
	EvtDiPmintPort008, 	"EvtDiPmintPort008",EvtDiPmintPort009, 	"EvtDiPmintPort009",EvtDiPmintPort010, 	"EvtDiPmintPort010",EvtDiPmintPort011,	"EvtDiPmintPort011",
	EvtDiPmintPort012, 	"EvtDiPmintPort012",EvtDiPmintPort013, 	"EvtDiPmintPort013",EvtDiPmintPort014, 	"EvtDiPmintPort014",EvtDiPmintPort015,	"EvtDiPmintPort015",
	EvtDiPmintPort016, 	"EvtDiPmintPort016",EvtDiPmintPort017, 	"EvtDiPmintPort017",EvtDiPmintPort018, 	"EvtDiPmintPort018",EvtDiPmintPort019,	"EvtDiPmintPort019",
	EvtDiPmintPort020, 	"EvtDiPmintPort020",EvtDiPmintPort021, 	"EvtDiPmintPort021",EvtDiPmintPort022, 	"EvtDiPmintPort022",EvtDiPmintPort023,	"EvtDiPmintPort023",
	EvtDiPmintPort024, 	"EvtDiPmintPort024",EvtDiPmintPort025, 	"EvtDiPmintPort025",EvtDiPmintPort026, 	"EvtDiPmintPort026",EvtDiPmintPort027,	"EvtDiPmintPort027",
	EvtDiPmintPort028, 	"EvtDiPmintPort028",EvtDiPmintPort029, 	"EvtDiPmintPort029",EvtDiPmintPort030, 	"EvtDiPmintPort030",EvtDiPmintPort031,	"EvtDiPmintPort031",

	EvtBufferedDiDataReady,		    "EvtBufferedDiDataReady",	
	EvtBufferedDiOverrun,			"EvtBufferedDiOverrun",
	EvtBufferedDiCacheOverflow,	    "EvtBufferedDiCacheOverflow",
	EvtBufferedDiStopped,			"EvtBufferedDiStopped",

	EvtBufferedDoDataTransmitted,	"EvtBufferedDoDataTransmitted",
	EvtBufferedDoUnderrun,		"EvtBufferedDoUnderrun",
	EvtBufferedDoCacheEmptied,	"EvtBufferedDoCacheEmptied",
	EvtBufferedDoTransStopped,	"EvtBufferedDoTransStopped",
	EvtBufferedDoStopped,		"EvtBufferedDoStopped",

	EvtReflectWdtOccured,	"EvtReflectWdtOccured",
	/*-----------------------------------------------------------------
	* Counter/Timer event IDs
	*-----------------------------------------------------------------*/
	EvtCntTerminalCount0, 	"EvtCntTerminalCount0",
	EvtCntTerminalCount1, 	"EvtCntTerminalCount1",
	EvtCntTerminalCount2, 	"EvtCntTerminalCount2",
	EvtCntTerminalCount3,	"EvtCntTerminalCount3",
	EvtCntTerminalCount4, 	"EvtCntTerminalCount4",
	EvtCntTerminalCount5, 	"EvtCntTerminalCount5",
	EvtCntTerminalCount6, 	"EvtCntTerminalCount6",
	EvtCntTerminalCount7,	"EvtCntTerminalCount7",

	EvtCntOverCompare0, 	"EvtCntOverCompare0",
	EvtCntOverCompare1, 	"EvtCntOverCompare1",
	EvtCntOverCompare2, 	"EvtCntOverCompare2",
	EvtCntOverCompare3,	    "EvtCntOverCompare3",
	EvtCntOverCompare4, 	"EvtCntOverCompare4",
	EvtCntOverCompare5, 	"EvtCntOverCompare5",
	EvtCntOverCompare6, 	"EvtCntOverCompare6",
	EvtCntOverCompare7,	    "EvtCntOverCompare7",

	EvtCntUnderCompare0, 	"EvtCntUnderCompare0",
	EvtCntUnderCompare1, 	"EvtCntUnderCompare1",
	EvtCntUnderCompare2, 	"EvtCntUnderCompare2",
	EvtCntUnderCompare3,	"EvtCntUnderCompare3",
	EvtCntUnderCompare4, 	"EvtCntUnderCompare4",
	EvtCntUnderCompare5, 	"EvtCntUnderCompare5",
	EvtCntUnderCompare6, 	"EvtCntUnderCompare6",
	EvtCntUnderCompare7,	"EvtCntUnderCompare7",

	EvtCntEcOverCompare0, 	"EvtCntEcOverCompare0",
	EvtCntEcOverCompare1, 	"EvtCntEcOverCompare1",
	EvtCntEcOverCompare2, 	"EvtCntEcOverCompare2",
	EvtCntEcOverCompare3,	"EvtCntEcOverCompare3",
	EvtCntEcOverCompare4, 	"EvtCntEcOverCompare4",
	EvtCntEcOverCompare5, 	"EvtCntEcOverCompare5",
	EvtCntEcOverCompare6, 	"EvtCntEcOverCompare6",
	EvtCntEcOverCompare7,	"EvtCntEcOverCompare7",

	EvtCntEcUnderCompare0, 	"EvtCntEcUnderCompare0",
	EvtCntEcUnderCompare1, 	"EvtCntEcUnderCompare1",
	EvtCntEcUnderCompare2, 	"EvtCntEcUnderCompare2",
	EvtCntEcUnderCompare3,	"EvtCntEcUnderCompare3",
	EvtCntEcUnderCompare4, 	"EvtCntEcUnderCompare4",
	EvtCntEcUnderCompare5, 	"EvtCntEcUnderCompare5",
	EvtCntEcUnderCompare6, 	"EvtCntEcUnderCompare6",
	EvtCntEcUnderCompare7,	"EvtCntEcUnderCompare7",

	EvtCntOneShot0, 	"EvtCntOneShot0",
	EvtCntOneShot1, 	"EvtCntOneShot1",
	EvtCntOneShot2, 	"EvtCntOneShot2",
	EvtCntOneShot3,	    "EvtCntOneShot3",
	EvtCntOneShot4, 	"EvtCntOneShot4",
	EvtCntOneShot5, 	"EvtCntOneShot5",
	EvtCntOneShot6, 	"EvtCntOneShot6",
	EvtCntOneShot7,	    "EvtCntOneShot7",

	EvtCntTimer0, 	"EvtCntTimer0",
	EvtCntTimer1, 	"EvtCntTimer1",
	EvtCntTimer2, 	"EvtCntTimer2",
	EvtCntTimer3,		"EvtCntTimer3",
	EvtCntTimer4, 	"EvtCntTimer4",
	EvtCntTimer5, 	"EvtCntTimer5",
	EvtCntTimer6, 	"EvtCntTimer6",
	EvtCntTimer7,		"EvtCntTimer7",

	EvtCntPwmInOverflow0, 	"EvtCntPwmInOverflow0",
	EvtCntPwmInOverflow1, 	"EvtCntPwmInOverflow1",
	EvtCntPwmInOverflow2, 	"EvtCntPwmInOverflow2",
	EvtCntPwmInOverflow3,		"EvtCntPwmInOverflow3",
	EvtCntPwmInOverflow4, 	"EvtCntPwmInOverflow4",
	EvtCntPwmInOverflow5, 	"EvtCntPwmInOverflow5",
	EvtCntPwmInOverflow6, 	"EvtCntPwmInOverflow6",
	EvtCntPwmInOverflow7,		"EvtCntPwmInOverflow7",

    EvtUdIndex0,    "EvtUdIndex0",
    EvtUdIndex1,    "EvtUdIndex1",
    EvtUdIndex2,    "EvtUdIndex2",
    EvtUdIndex3,    "EvtUdIndex3",
    EvtUdIndex4,    "EvtUdIndex4",
    EvtUdIndex5,    "EvtUdIndex5",
    EvtUdIndex6,    "EvtUdIndex6",
    EvtUdIndex7,    "EvtUdIndex7",
    
    EvtCntPatternMatch0,   "EvtCntPatternMatch0",
    EvtCntPatternMatch1,   "EvtCntPatternMatch1",
    EvtCntPatternMatch2,   "EvtCntPatternMatch2",
    EvtCntPatternMatch3,   "EvtCntPatternMatch3",
    EvtCntPatternMatch4,   "EvtCntPatternMatch4",
    EvtCntPatternMatch5,   "EvtCntPatternMatch5",
    EvtCntPatternMatch6,   "EvtCntPatternMatch6",
    EvtCntPatternMatch7,   "EvtCntPatternMatch7",
    
    EvtCntCompareTableEnd0, "EvtCntCompareTableEnd0",
    EvtCntCompareTableEnd1, "EvtCntCompareTableEnd1",
    EvtCntCompareTableEnd2, "EvtCntCompareTableEnd2",
    EvtCntCompareTableEnd3, "EvtCntCompareTableEnd3",
    EvtCntCompareTableEnd4, "EvtCntCompareTableEnd4",
    EvtCntCompareTableEnd5, "EvtCntCompareTableEnd5",
    EvtCntCompareTableEnd6, "EvtCntCompareTableEnd6",
    EvtCntCompareTableEnd7, "EvtCntCompareTableEnd7"
};

int Type_EventId::count = TYPE_EVENTID;

char* Type_EventId::GetPropertySpec(int id)
{
	for (int i = 0; i < Type_EventId::count; ++i)
	{
		if (Type_EventId::content[i].iID == id)
		{
			return Type_EventId::content[i].strSpec;
		}
	}
	return "undefine ID";
}

int Type_EventId::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_EventId::count; ++i)
    {
        if (0 == strcmp(caption, Type_EventId::content[i].strSpec))
        {
            return Type_EventId::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_PropertyAttribute::content[TYPE_PROPERTYATTRIBUTE] = {
    ReadOnly ,	"ReadOnly",
        Writable ,	"Writable",
        Modal ,	"Modal",
        Nature,	"Nature"
};

int Type_PropertyAttribute::count = TYPE_PROPERTYATTRIBUTE;

char* Type_PropertyAttribute::GetPropertySpec(int id)
{
    id = id & 0x1;
    for (int i = 0; i < Type_PropertyAttribute::count; ++i)
    {
        if (Type_PropertyAttribute::content[i].iID == id)
        {
            return Type_PropertyAttribute::content[i].strSpec;
        }
    }
    return "undefine ID";
}


int Type_PropertyAttribute::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_PropertyAttribute::count; ++i)
    {
        if (0 == strcmp(caption, Type_PropertyAttribute::content[i].strSpec))
        {
            return Type_PropertyAttribute::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_ProductId::content[TYPE_PRODUCTID] = {
	BD_DEMO,	"BD_DEMO",		// demo board
	BD_PCL818,	"BD_PCL818",		// PCL-818 board
	BD_PCL818H,	"BD_PCL818H",	// PCL-818H
	BD_PCL818L,	"BD_PCL818L",	// PCL-818L
	BD_PCL818HG,	"BD_PCL818HG",	// PCL-818HG
	BD_PCL818HD,	"BD_PCL818HD",	// PCL-818HD
	BD_PCM3718,	"BD_PCM3718",	// PCM-3718
	BD_PCM3724,	"BD_PCM3724",	// PCM-3724
	BD_PCM3730,	"BD_PCM3730",	// PCM-3730
	BD_PCI1750,	"BD_PCI1750",	// PCI-1750
	BD_PCI1751,	"BD_PCI1751",	// PCI-1751
	BD_PCI1710,	"BD_PCI1710",	// PCI-1710
	BD_PCI1712,	"BD_PCI1712",	// PCI-1712
	BD_PCI1710HG,	"BD_PCI1710HG",	// PCI-1710HG
	BD_PCI1711,		"BD_PCI1711",// PCI-1711
	BD_PCI1711L,	"BD_PCI1711L",// PCI-1711L 
	BD_PCI1713,		"BD_PCI1713",// PCI-1713
	BD_PCI1753,		"BD_PCI1753",// PCI-1753
	BD_PCI1760,		"BD_PCI1760",// PCI-1760
	BD_PCI1720,		"BD_PCI1720",// PCI-1720
	BD_PCM3718H,	"BD_PCM3718H",// PCM-3718H
	BD_PCM3718HG,	"BD_PCM3718HG",	// PCM-3718HG
	BD_PCI1716,	"BD_PCI1716",	// PCI-1716
	BD_PCI1731,	"BD_PCI1731",	// PCI-1731
	BD_PCI1754,	"BD_PCI1754",	// PCI-1754
	BD_PCI1752,	"BD_PCI1752",	// PCI-1752
	BD_PCI1756,	"BD_PCI1756",	// PCI-1756
	BD_PCM3725,	"BD_PCM3725",	// PCM-3725
	BD_PCI1762,	"BD_PCI1762",	// PCI-1762
	BD_PCI1721,	"BD_PCI1721",	// PCI-1721
	BD_PCI1761,	"BD_PCI1761",	// PCI-1761
	BD_PCI1723,	"BD_PCI1723",	// PCI-1723
	BD_PCI1730,	"BD_PCI1730",	// PCI-1730
	BD_PCI1733,	"BD_PCI1733",	// PCI-1733
	BD_PCI1734,	"BD_PCI1734",	// PCI-1734
	BD_PCI1710L,	"BD_PCI1710L",	// PCI-1710L
	BD_PCI1710HGL,	"BD_PCI1710HGL",// PCI-1710HGL
	BD_PCM3712,	    "BD_PCM3712",	// PCM-3712
	BD_PCM3723,	    "BD_PCM3723",	// PCM-3723
	BD_PCI1780,	    "BD_PCI1780",	// PCI-1780
	BD_CPCI3756,	"BD_CPCI3756",	// CPCI-3756
	BD_PCI1755,	"BD_PCI1755",	// PCI-1755
	BD_PCI1714,	"BD_PCI1714",	// PCI-1714
	BD_PCI1757,	"BD_PCI1757",	// PCI-1757
	BD_MIC3716,	"BD_MIC3716",	// MIC-3716
	BD_MIC3761,	"BD_MIC3761",	// MIC-3761
	BD_MIC3753,	"BD_MIC3753",		// MIC-3753
	BD_MIC3780,	"BD_MIC3780",		// MIC-3780
	BD_PCI1724,	"BD_PCI1724",		// PCI-1724
	BD_PCI1758UDI,	"BD_PCI1758UDI",	// PCI-1758UDI
	BD_PCI1758UDO,	"BD_PCI1758UDO",	// PCI-1758UDO
	BD_PCI1747,	"BD_PCI1747",		// PCI-1747
	BD_PCM3780,	"BD_PCM3780",		// PCM-3780 
	BD_MIC3747,	"BD_MIC3747",		// MIC-3747
	BD_PCI1758UDIO,	"BD_PCI1758UDIO",	// PCI-1758UDIO
	BD_PCI1712L ,	"BD_PCI1712L",		// PCI-1712L
	BD_PCI1763UP,	"BD_PCI1763UP",	   // PCI-1763UP
	BD_PCI1736UP,	"BD_PCI1736UP",	   // PCI-1736UP
	BD_PCI1714UL,	"BD_PCI1714UL",	   // PCI-1714UL
	BD_MIC3714,	    "BD_MIC3714",	// MIC-3714
	BD_PCM3718HO,	"BD_PCM3718HO",	   // PCM-3718HO
	BD_PCI1741U,	"BD_PCI1741U",	// PCI-1741U
	BD_MIC3723,		"BD_MIC3723",	// MIC-3723 
	BD_PCI1718HDU,	"BD_PCI1718HDU",	// PCI-1718HDU
	BD_MIC3758DIO,	"BD_MIC3758DIO",	// MIC-3758DIO
	BD_PCI1727U,	"BD_PCI1727U",	// PCI-1727U
	BD_PCI1718HGU,	"BD_PCI1718HGU",	// PCI-1718HGU
	BD_PCI1715U,	"BD_PCI1715U",		// PCI-1715U
	BD_PCI1716L,	"BD_PCI1716L",		// PCI-1716L
	BD_PCI1735U,	"BD_PCI1735U",		// PCI-1735U
	BD_USB4711,	    "BD_USB4711",	// USB4711
	BD_PCI1737U,	"BD_PCI1737U",		// PCI-1737U
	BD_PCI1739U,	"BD_PCI1739U",		// PCI-1739U
	BD_PCI1742U,	"BD_PCI1742U",		// PCI-1742U
	BD_USB4718,	"BD_USB4718",	// USB-4718
	BD_MIC3755,	"BD_MIC3755",		// MIC3755
	BD_USB4761,	"BD_USB4761",		// USB4761
	BD_PCI1784,	"BD_PCI1784",		// PCI-1784
	BD_USB4716,	"BD_USB4716",		// USB4716
	BD_PCI1752U,	"BD_PCI1752U",		// PCI-1752U
	BD_PCI1752USO,	"BD_PCI1752USO",	// PCI-1752USO
	BD_USB4751,		"BD_USB4751",	// USB4751
	BD_USB4751L,	"BD_USB4751L",	// USB4751L
	BD_USB4750,		"BD_USB4750",	// USB4750
	BD_MIC3713,		"BD_MIC3713",	// MIC-3713
	BD_USB4711A,	"BD_USB4711A",	// USB4711A
	BD_PCM3753P,	"BD_PCM3753P",	// PCM3753P
	BD_PCM3784,		"BD_PCM3784 ",		// PCM3784
	BD_PCM3761I,	"BD_PCM3761I",     // PCM-3761I
	BD_MIC3751,		"BD_MIC3751 ",     // MIC-3751
	BD_PCM3730I,	"BD_PCM3730I",     // PCM-3730I
	BD_PCM3813I,	"BD_PCM3813I",     // PCM-3813I
	BD_PCIE1744,	"BD_PCIE1744",     //PCIE-1744
	BD_PCI1730U,	"BD_PCI1730U", 	   // PCI-1730U
	BD_PCI1760U,	"BD_PCI1760U",	   //PCI-1760U
	BD_MIC3720,		"BD_MIC3720",	   //MIC-3720
	BD_PCM3810I,	"BD_PCM3810I",     // PCM-3810I
	BD_USB4702,		"BD_USB4702 ",     // USB4702
	BD_USB4704,		"BD_USB4704 ",     // USB4704
	BD_PCM3810I_HG,	"BD_PCM3810I_HG",  // PCM-3810I_HG
	BD_PCI1713U,	"BD_PCI1713U",// PCI-1713U 
	// !!!BioDAQ only Product ID starts from here!!!
	BD_PCI1706U,	"BD_PCI1706U", 
	BD_PCI1706MSU,	"BD_PCI1706MSU", 
	BD_PCI1706UL,	"BD_PCI1706UL", 
	BD_PCIE1752,	"BD_PCIE1752", 
	BD_PCIE1754,	"BD_PCIE1754", 
	BD_PCIE1756,	"BD_PCIE1756",
	BD_MIC1911,		"BD_MIC1911",
	BD_MIC3750,		"BD_MIC3750", 
	BD_MIC3711,		"BD_MIC3711", 
	BD_PCIE1730,	"BD_PCIE1730",
    BD_PCI1710_ECU, "BD_PCI1710_ECU", 
    BD_PCI1720_ECU, "BD_PCI1720_ECU", 
    BD_PCIE1760,    "BD_PCIE1760"   
};

int Type_ProductId::count = TYPE_PRODUCTID;

char* Type_ProductId::GetPropertySpec(int id)
{
	for (int i = 0; i < Type_ProductId::count; ++i)
	{
		if (Type_ProductId::content[i].iID == id)
		{
			return Type_ProductId::content[i].strSpec;
		}
	}
	return "undefine ID";
}

int Type_ProductId::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_ProductId::count; ++i)
    {
        if (0 == strcmp(caption, Type_ProductId::content[i].strSpec))
        {
            return Type_ProductId::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_Bool::content[TYPE_BOOL] = {
    false ,	"FALSE",
        true ,	"TRUE"	
};

int Type_Bool::count = TYPE_BOOL;

char* Type_Bool::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_Bool::count; ++i)
    {
        if (Type_Bool::content[i].iID == id)
        {
            return Type_Bool::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_Bool::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_Bool::count; ++i)
    {
        if (0 == strcmp(caption, Type_Bool::content[i].strSpec))
        {
            return Type_Bool::content[i].iID;
        }
    }
    return -1;
}


//////////////////////
SPEC_PROPERTY Type_Int32::content[TYPE_INT32] = {
    0 ,	"Int32",
};

int Type_Int32::count = TYPE_INT32;

char* Type_Int32::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_Int32::count; ++i)
    {
        if (Type_Int32::content[i].iID == id)
        {
            return Type_Int32::content[i].strSpec;
        }
    }
    return "undefine ID";
}

//////////////////////
SPEC_PROPERTY Type_Double::content[TYPE_DOUBLE] = {
    0 ,	"Double",
};

int Type_Double::count = TYPE_DOUBLE;

char* Type_Double::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_Double::count; ++i)
    {
        if (Type_Double::content[i].iID == id)
        {
            return Type_Double::content[i].strSpec;
        }
    }
    return "undefine ID";
}

//////////////////////
SPEC_PROPERTY Type_PulseWidth::content[TYPE_PULSEWIDTH] = {
    0 ,	"Int32",
};

int Type_PulseWidth::count = TYPE_PULSEWIDTH;

char* Type_PulseWidth:: GetPropertySpec(PulseWidth pulsewidth)
{
    static char out[200];
    sprintf(out, "HiPeriod: %12.8lf\r\nLoPeriod: %12.8lf\r\n", pulsewidth.HiPeriod, pulsewidth.LoPeriod);
    return out;
}

//////////////////////
SPEC_PROPERTY Type_PropertyID::content[TYPE_RPOPERTYID] = {
    CFG_Number,                              "CFG_Number",                             
   CFG_ComponentType,                       "CFG_ComponentType",
   CFG_Description,                         "CFG_Description",
   CFG_Parent,                              "CFG_Parent",
   CFG_ChildList,                           "CFG_ChildList",
   CFG_DevicesNumber,                       "CFG_DevicesNumber",
   CFG_DevicesHandle,                       "CFG_DevicesHandle",
   CFG_DeviceGroupNumber,                   "CFG_DeviceGroupNumber",
   CFG_DeviceProductID,                     "CFG_DeviceProductID",
   CFG_DeviceBoardID,                       "CFG_DeviceBoardID",
   CFG_DeviceBoardVersion,                  "CFG_DeviceBoardVersion",
   CFG_DeviceDriverVersion,                 "CFG_DeviceDriverVersion",
   CFG_DeviceDllVersion,                    "CFG_DeviceDllVersion",
   CFG_DeviceLocation,                      "CFG_DeviceLocation",                   
   CFG_DeviceBaseAddresses,                 "CFG_DeviceBaseAddresses",              
   CFG_DeviceInterrupts,                    "CFG_DeviceInterrupts",                 
   CFG_DeviceSupportedTerminalBoardTypes,   "CFG_DeviceSupportedTerminalBoardTypes",
   CFG_DeviceTerminalBoardType,             "CFG_DeviceTerminalBoardType",          
   CFG_DeviceSupportedEvents,               "CFG_DeviceSupportedEvents",
   CFG_DeviceHotResetPreventable,           "CFG_DeviceHotResetPreventable",        
   CFG_DeviceLoadingTimeInit,              "CFG_DeviceLoadingTimeInit",            
   CFG_DeviceWaitingForReconnect,          "CFG_DeviceWaitingForReconnect",
   CFG_DeviceWaitingForSleep,              "CFG_DeviceWaitingForSleep",
   CFG_FeatureResolutionInBit,             "CFG_FeatureResolutionInBit",
   CFG_FeatureDataSize,                    "CFG_FeatureDataSize",
   CFG_FeatureDataMask,                    "CFG_FeatureDataMask",
   CFG_FeatureChannelNumberMax,            "CFG_FeatureChannelNumberMax",
   CFG_FeatureChannelConnectionType,       "CFG_FeatureChannelConnectionType",
   CFG_FeatureBurnDetectedReturnTypes,     "CFG_FeatureBurnDetectedReturnTypes",
   CFG_FeatureBurnoutDetectionChannels,    "CFG_FeatureBurnoutDetectionChannels",
   CFG_FeatureOverallVrgType,              "CFG_FeatureOverallVrgType",
   CFG_FeatureVrgTypes,                    "CFG_FeatureVrgTypes",
   CFG_FeatureExtRefRange,                 "CFG_FeatureExtRefRange",
   CFG_FeatureExtRefAntiPolar,             "CFG_FeatureExtRefAntiPolar",
   CFG_FeatureCjcChannels,                 "CFG_FeatureCjcChannels",
   CFG_FeatureChannelScanMethod,           "CFG_FeatureChannelScanMethod",
   CFG_FeatureScanChannelStartBase,        "CFG_FeatureScanChannelStartBase",
   CFG_FeatureScanChannelCountBase,        "CFG_FeatureScanChannelCountBase",
   CFG_FeatureConvertClockSources,         "CFG_FeatureConvertClockSources",
   CFG_FeatureConvertClockRateRange,       "CFG_FeatureConvertClockRateRange",  
   CFG_FeatureScanClockSources,            "CFG_FeatureScanClockSources",
   CFG_FeatureScanClockRateRange,          "CFG_FeatureScanClockRateRange",     
   CFG_FeatureScanCountMax,                "CFG_FeatureScanCountMax",           
   CFG_FeatureTriggersCount,               "CFG_FeatureTriggersCount",
   CFG_FeatureTriggerSources,              "CFG_FeatureTriggerSources",
   CFG_FeatureTriggerActions,              "CFG_FeatureTriggerActions",
   CFG_FeatureTriggerDelayCountRange,      "CFG_FeatureTriggerDelayCountRange",
   CFG_FeatureTriggerSources1,             "CFG_FeatureTriggerSources1",        
   CFG_FeatureTriggerActions1,             "CFG_FeatureTriggerActions1",        
   CFG_FeatureTriggerDelayCountRange1,     "CFG_FeatureTriggerDelayCountRange1",
   CFG_ChannelCount,                       "CFG_ChannelCount",
   CFG_ConnectionTypeOfChannels,           "CFG_ConnectionTypeOfChannels",
   CFG_VrgTypeOfChannels,                  "CFG_VrgTypeOfChannels",
   CFG_BurnDetectedReturnTypeOfChannels,   "CFG_BurnDetectedReturnTypeOfChannels",
   CFG_BurnoutReturnValueOfChannels,       "CFG_BurnoutReturnValueOfChannels",
   CFG_ExtRefValueForUnipolar,             "CFG_ExtRefValueForUnipolar",          
   CFG_ExtRefValueForBipolar,              "CFG_ExtRefValueForBipolar",           
   CFG_CjcChannel,                         "CFG_CjcChannel",
   CFG_CjcUpdateFrequency,                 "CFG_CjcUpdateFrequency",              
   CFG_CjcValue,                           "CFG_CjcValue",
   CFG_SectionDataCount,                   "CFG_SectionDataCount",
   CFG_ConvertClockSource,                 "CFG_ConvertClockSource",
   CFG_ConvertClockRatePerChannel,         "CFG_ConvertClockRatePerChannel",
   CFG_ScanChannelStart,                   "CFG_ScanChannelStart",
   CFG_ScanChannelCount,                   "CFG_ScanChannelCount",
   CFG_ScanClockSource,                    "CFG_ScanClockSource",                 
   CFG_ScanClockRate,                      "CFG_ScanClockRate",                   
   CFG_ScanCount,                          "CFG_ScanCount",                       
   CFG_TriggerSource,                      "CFG_TriggerSource",
   CFG_TriggerSourceEdge,                  "CFG_TriggerSourceEdge",
   CFG_TriggerSourceLevel,                 "CFG_TriggerSourceLevel",
   CFG_TriggerDelayCount,                  "CFG_TriggerDelayCount",
   CFG_TriggerAction,                      "CFG_TriggerAction",
   CFG_TriggerSource1,                     "CFG_TriggerSource1",                
   CFG_TriggerSourceEdge1,                 "CFG_TriggerSourceEdge1",            
   CFG_TriggerSourceLevel1,                "CFG_TriggerSourceLevel1",           
   CFG_TriggerDelayCount1,                 "CFG_TriggerDelayCount1",            
   CFG_TriggerAction1,                     "CFG_TriggerAction1",                
   CFG_ParentSignalConnectionChannel,      "CFG_ParentSignalConnectionChannel",
   CFG_ParentCjcConnectionChannel,         "CFG_ParentCjcConnectionChannel",
   CFG_ParentControlPort,                  "CFG_ParentControlPort",
   CFG_FeaturePortsCount,                  "CFG_FeaturePortsCount",
   CFG_FeaturePortsType,                   "CFG_FeaturePortsType",
   CFG_FeatureNoiseFilterOfChannels,       "CFG_FeatureNoiseFilterOfChannels",
   CFG_FeatureNoiseFilterBlockTimeRange,   "CFG_FeatureNoiseFilterBlockTimeRange",
   CFG_FeatureDiintTriggerEdges,           "CFG_FeatureDiintTriggerEdges",
   CFG_FeatureDiintOfChannels,             "CFG_FeatureDiintOfChannels",
   CFG_FeatureDiintGateOfChannels,         "CFG_FeatureDiintGateOfChannels",
   CFG_FeatureDiCosintOfChannels,          "CFG_FeatureDiCosintOfChannels",
   CFG_FeatureDiPmintOfChannels,           "CFG_FeatureDiPmintOfChannels",
   CFG_FeatureSnapEventSources,            "CFG_FeatureSnapEventSources",
   CFG_FeatureDiSnapEventSources,          "CFG_FeatureDiSnapEventSources",
   CFG_FeatureDoFreezeSignalSources,       "CFG_FeatureDoFreezeSignalSources",              
   CFG_FeatureDoReflectWdtFeedIntervalRange,    " CFG_FeatureDoReflectWdtFeedIntervalRange",
   CFG_FeatureDiPortScanMethod,            "CFG_FeatureDiPortScanMethod",                   
   CFG_FeatureDiConvertClockSources,       "CFG_FeatureDiConvertClockSources",              
   CFG_FeatureDiConvertClockRateRange,     "CFG_FeatureDiConvertClockRateRange",            
   CFG_FeatureDiScanClockSources,          "CFG_FeatureDiScanClockSources",
   CFG_FeatureDiScanClockRateRange,        "CFG_FeatureDiScanClockRateRange",               
   CFG_FeatureDiScanCountMax,              "CFG_FeatureDiScanCountMax",
   CFG_FeatureDiTriggersCount,             "CFG_FeatureDiTriggersCount",
   CFG_FeatureDiTriggerSources,            "CFG_FeatureDiTriggerSources",
   CFG_FeatureDiTriggerActions,            "CFG_FeatureDiTriggerActions",
   CFG_FeatureDiTriggerDelayCountRange,    "CFG_FeatureDiTriggerDelayCountRange",
   CFG_FeatureDiTriggerSources1,           "CFG_FeatureDiTriggerSources1",
   CFG_FeatureDiTriggerActions1,           "CFG_FeatureDiTriggerActions1",
   CFG_FeatureDiTriggerDelayCountRange1,   "CFG_FeatureDiTriggerDelayCountRange1",
   CFG_FeatureDoPortScanMethod,            "CFG_FeatureDoPortScanMethod",           
   CFG_FeatureDoConvertClockSources,       "CFG_FeatureDoConvertClockSources",      
   CFG_FeatureDoConvertClockRateRange,     "CFG_FeatureDoConvertClockRateRange",    
   CFG_FeatureDoScanClockSources,          "CFG_FeatureDoScanClockSources",
   CFG_FeatureDoScanClockRateRange,        "CFG_FeatureDoScanClockRateRange",       
   CFG_FeatureDoScanCountMax,              "CFG_FeatureDoScanCountMax",
   CFG_FeatureDoTriggersCount,             "CFG_FeatureDoTriggersCount",
   CFG_FeatureDoTriggerSources,            "CFG_FeatureDoTriggerSources",
   CFG_FeatureDoTriggerActions,            "CFG_FeatureDoTriggerActions",
   CFG_FeatureDoTriggerDelayCountRange,    "CFG_FeatureDoTriggerDelayCountRange",
   CFG_FeatureDoTriggerSources1,           "CFG_FeatureDoTriggerSources1",
   CFG_FeatureDoTriggerActions1,           "CFG_FeatureDoTriggerActions1",
   CFG_FeatureDoTriggerDelayCountRange1,   "CFG_FeatureDoTriggerDelayCountRange1",
   CFG_DirectionOfPorts,                   "CFG_DirectionOfPorts",
   CFG_DiDataMaskOfPorts,                  "CFG_DiDataMaskOfPorts",
   CFG_DoDataMaskOfPorts,                  "CFG_DoDataMaskOfPorts",
   CFG_NoiseFilterOverallBlockTime,        "CFG_NoiseFilterOverallBlockTime", 
   CFG_NoiseFilterEnabledChannels,         "CFG_NoiseFilterEnabledChannels",
   CFG_DiintTriggerEdgeOfChannels,         "CFG_DiintTriggerEdgeOfChannels",
   CFG_DiintGateEnabledChannels,           "CFG_DiintGateEnabledChannels",
   CFG_DiCosintEnabledChannels,            "CFG_DiCosintEnabledChannels",
   CFG_DiPmintEnabledChannels,             "CFG_DiPmintEnabledChannels",
   CFG_DiPmintValueOfPorts,                "CFG_DiPmintValueOfPorts",
   CFG_DoInitialStateOfPorts,              "CFG_DoInitialStateOfPorts",        
   CFG_DoFreezeEnabled,                    "CFG_DoFreezeEnabled",              
   CFG_DoFreezeSignalState,                "CFG_DoFreezeSignalState",          
   CFG_DoReflectWdtFeedInterval,           "CFG_DoReflectWdtFeedInterval", 
   CFG_DoReflectWdtLockValue,              "CFG_DoReflectWdtLockValue",        
   CFG_DiSectionDataCount,                 "CFG_DiSectionDataCount",
   CFG_DiConvertClockSource,               "CFG_DiConvertClockSource",
   CFG_DiConvertClockRatePerPort,          "CFG_DiConvertClockRatePerPort",
   CFG_DiScanPortStart,                    "CFG_DiScanPortStart",
   CFG_DiScanPortCount,                    "CFG_DiScanPortCount",
   CFG_DiScanClockSource,                  "CFG_DiScanClockSource",
   CFG_DiScanClockRate,                    "CFG_DiScanClockRate",
   CFG_DiScanCount,                        "CFG_DiScanCount",
   CFG_DiTriggerAction,                    "CFG_DiTriggerAction",
   CFG_DiTriggerSource,                    "CFG_DiTriggerSource",
   CFG_DiTriggerSourceEdge,                "CFG_DiTriggerSourceEdge",
   CFG_DiTriggerSourceLevel,               "CFG_DiTriggerSourceLevel",                              
   CFG_DiTriggerDelayCount,                "CFG_DiTriggerDelayCount",
   CFG_DiTriggerAction1,                   "CFG_DiTriggerAction1",
   CFG_DiTriggerSource1,                   "CFG_DiTriggerSource1",
   CFG_DiTriggerSourceEdge1,               "CFG_DiTriggerSourceEdge1",
   CFG_DiTriggerSourceLevel1,              "CFG_DiTriggerSourceLevel1",                            
   CFG_DiTriggerDelayCount1,               "CFG_DiTriggerDelayCount1",
   CFG_DoSectionDataCount,                 "CFG_DoSectionDataCount",
   CFG_DoConvertClockSource,               "CFG_DoConvertClockSource",
   CFG_DoConvertClockRatePerPort,          "CFG_DoConvertClockRatePerPort",
   CFG_DoScanPortStart,                    "CFG_DoScanPortStart",
   CFG_DoScanPortCount,                    "CFG_DoScanPortCount",
   CFG_DoScanClockSource,                  "CFG_DoScanClockSource",
   CFG_DoScanClockRate,                    "CFG_DoScanClockRate",
   CFG_DoScanCount,                        "CFG_DoScanCount",
   CFG_DoTriggerAction,                    "CFG_DoTriggerAction",
   CFG_DoTriggerSource,                    "CFG_DoTriggerSource",
   CFG_DoTriggerSourceEdge,                "CFG_DoTriggerSourceEdge",
   CFG_DoTriggerSourceLevel,               "CFG_DoTriggerSourceLevel",                             
   CFG_DoTriggerDelayCount,                "CFG_DoTriggerDelayCount",
   CFG_DoTriggerAction1,                   "CFG_DoTriggerAction1",
   CFG_DoTriggerSource1,                   "CFG_DoTriggerSource1",
   CFG_DoTriggerSourceEdge1,               "CFG_DoTriggerSourceEdge1",
   CFG_DoTriggerSourceLevel1,              "CFG_DoTriggerSourceLevel1",                          
   CFG_DoTriggerDelayCount1,               "CFG_DoTriggerDelayCount1",
   CFG_FeatureCapabilitiesOfCounter0,      "CFG_FeatureCapabilitiesOfCounter0",
   CFG_FeatureCapabilitiesOfCounter1,      "CFG_FeatureCapabilitiesOfCounter1",
   CFG_FeatureCapabilitiesOfCounter2,      "CFG_FeatureCapabilitiesOfCounter2",
   CFG_FeatureCapabilitiesOfCounter3,      "CFG_FeatureCapabilitiesOfCounter3",
   CFG_FeatureCapabilitiesOfCounter4,      "CFG_FeatureCapabilitiesOfCounter4",
   CFG_FeatureCapabilitiesOfCounter5,      "CFG_FeatureCapabilitiesOfCounter5",
   CFG_FeatureCapabilitiesOfCounter6,      "CFG_FeatureCapabilitiesOfCounter6",
   CFG_FeatureCapabilitiesOfCounter7,      "CFG_FeatureCapabilitiesOfCounter7",
   CFG_FeatureChipOperationModes,          "CFG_FeatureChipOperationModes",
   CFG_FeatureChipSignalCountingTypes,     "CFG_FeatureChipSignalCountingTypes",
   CFG_FeatureTmrCascadeGroups,            "CFG_FeatureTmrCascadeGroups",            
   CFG_FeatureFmMethods,                   "CFG_FeatureFmMethods",
   CFG_ChipOperationModeOfCounters,        "CFG_ChipOperationModeOfCounters",
   CFG_ChipSignalCountingTypeOfCounters,   "CFG_ChipSignalCountingTypeOfCounters",
   CFG_ChipLoadValueOfCounters,            "CFG_ChipLoadValueOfCounters",
   CFG_ChipHoldValueOfCounters,            "CFG_ChipHoldValueOfCounters",
   CFG_ChipOverCompareValueOfCounters,     "CFG_ChipOverCompareValueOfCounters",
   CFG_ChipUnderCompareValueOfCounters,    "CFG_ChipUnderCompareValueOfCounters",
   CFG_ChipOverCompareEnabledCounters,     "CFG_ChipOverCompareEnabledCounters",
   CFG_ChipUnderCompareEnabledCounters,    "CFG_ChipUnderCompareEnabledCounters",
   CFG_FmMethodOfCounters,                 "CFG_FmMethodOfCounters",
   CFG_FmCollectionPeriodOfCounters,       "CFG_FmCollectionPeriodOfCounters",
   CFG_DevicePrivateRegionLength,          "CFG_DevicePrivateRegionLength",
   CFG_SaiAutoConvertClockRate,            "CFG_SaiAutoConvertClockRate",
   CFG_SaiAutoConvertChannelStart,         "CFG_SaiAutoConvertChannelStart",
   CFG_SaiAutoConvertChannelCount,         "CFG_SaiAutoConvertChannelCount",
   CFG_ExtPauseSignalEnabled,              "CFG_ExtPauseSignalEnabled",
   CFG_ExtPauseSignalPolarity,             "CFG_ExtPauseSignalPolarity",
   CFG_OrderOfChannels,                    "CFG_OrderOfChannels",
   CFG_InitialStateOfChannels,             "CFG_InitialStateOfChannels",
   CFG_FeatureChipClkSourceOfCounter0,     "CFG_FeatureChipClkSourceOfCounter0",     
   CFG_FeatureChipClkSourceOfCounter1,     "CFG_FeatureChipClkSourceOfCounter1",
   CFG_FeatureChipClkSourceOfCounter2,     "CFG_FeatureChipClkSourceOfCounter2",
   CFG_FeatureChipClkSourceOfCounter3,     "CFG_FeatureChipClkSourceOfCounter3",
   CFG_FeatureChipClkSourceOfCounter4,     "CFG_FeatureChipClkSourceOfCounter4",
   CFG_FeatureChipClkSourceOfCounter5,     "CFG_FeatureChipClkSourceOfCounter5",
   CFG_FeatureChipClkSourceOfCounter6,     "CFG_FeatureChipClkSourceOfCounter6",
   CFG_FeatureChipClkSourceOfCounter7,     "CFG_FeatureChipClkSourceOfCounter7",
   CFG_FeatureChipGateSourceOfCounter0,    "CFG_FeatureChipGateSourceOfCounter0",
   CFG_FeatureChipGateSourceOfCounter1,    "CFG_FeatureChipGateSourceOfCounter1",
   CFG_FeatureChipGateSourceOfCounter2,    "CFG_FeatureChipGateSourceOfCounter2",
   CFG_FeatureChipGateSourceOfCounter3,    "CFG_FeatureChipGateSourceOfCounter3",
   CFG_FeatureChipGateSourceOfCounter4,    "CFG_FeatureChipGateSourceOfCounter4",
   CFG_FeatureChipGateSourceOfCounter5,    "CFG_FeatureChipGateSourceOfCounter5",
   CFG_FeatureChipGateSourceOfCounter6,    "CFG_FeatureChipGateSourceOfCounter6",
   CFG_FeatureChipGateSourceOfCounter7,    "CFG_FeatureChipGateSourceOfCounter7",
   CFG_FeatureChipValueRegisters,          "CFG_FeatureChipValueRegisters",
   CFG_FeatureOsClkSourceOfCounter0,       "CFG_FeatureOsClkSourceOfCounter0",
   CFG_FeatureOsClkSourceOfCounter1,       "CFG_FeatureOsClkSourceOfCounter1",
   CFG_FeatureOsClkSourceOfCounter2,       "CFG_FeatureOsClkSourceOfCounter2",
   CFG_FeatureOsClkSourceOfCounter3,       "CFG_FeatureOsClkSourceOfCounter3",
   CFG_FeatureOsClkSourceOfCounter4,       "CFG_FeatureOsClkSourceOfCounter4",
   CFG_FeatureOsClkSourceOfCounter5,       "CFG_FeatureOsClkSourceOfCounter5",
   CFG_FeatureOsClkSourceOfCounter6,       "CFG_FeatureOsClkSourceOfCounter6",
   CFG_FeatureOsClkSourceOfCounter7,       "CFG_FeatureOsClkSourceOfCounter7",
   CFG_FeatureOsGateSourceOfCounter0,      "CFG_FeatureOsGateSourceOfCounter0",
   CFG_FeatureOsGateSourceOfCounter1,      "CFG_FeatureOsGateSourceOfCounter1",
   CFG_FeatureOsGateSourceOfCounter2,      "CFG_FeatureOsGateSourceOfCounter2",
   CFG_FeatureOsGateSourceOfCounter3,      "CFG_FeatureOsGateSourceOfCounter3",
   CFG_FeatureOsGateSourceOfCounter4,      "CFG_FeatureOsGateSourceOfCounter4",
   CFG_FeatureOsGateSourceOfCounter5,      "CFG_FeatureOsGateSourceOfCounter5",
   CFG_FeatureOsGateSourceOfCounter6,      "CFG_FeatureOsGateSourceOfCounter6",
   CFG_FeatureOsGateSourceOfCounter7,      "CFG_FeatureOsGateSourceOfCounter7",
   CFG_FeaturePiCascadeGroups,             "CFG_FeaturePiCascadeGroups",           
   CFG_ChipClkSourceOfCounters,            "CFG_ChipClkSourceOfCounters", 
   CFG_ChipGateSourceOfCounters,           "CFG_ChipGateSourceOfCounters",
   CFG_OsClkSourceOfCounters,              "CFG_OsClkSourceOfCounters", 
   CFG_OsGateSourceOfCounters,             "CFG_OsGateSourceOfCounters",
   CFG_OsDelayCountOfCounters,             "CFG_OsDelayCountOfCounters",
   CFG_TmrFrequencyOfCounters,             "CFG_TmrFrequencyOfCounters",
   CFG_PoHiPeriodOfCounters,               "CFG_PoHiPeriodOfCounters",
   CFG_PoLoPeriodOfCounters,               "CFG_PoLoPeriodOfCounters",
   CFG_FeatureEcClkPolarities,             "CFG_FeatureEcClkPolarities",
   CFG_FeatureEcGatePolarities,            "CFG_FeatureEcGatePolarities",
   CFG_FeatureEcGateControlOfCounters,     "CFG_FeatureEcGateControlOfCounters",
   CFG_EcClkPolarityOfCounters,            "CFG_EcClkPolarityOfCounters",
   CFG_EcGatePolarityOfCounters,           "CFG_EcGatePolarityOfCounters",
   CFG_EcGateEnabledOfCounters,            "CFG_EcGateEnabledOfCounters",
   CFG_FeatureOsClkPolarities,             "CFG_FeatureOsClkPolarities",
   CFG_FeatureOsGatePolarities,            "CFG_FeatureOsGatePolarities",
   CFG_FeatureOsOutSignals,                "CFG_FeatureOsOutSignals",
   CFG_OsClkPolarityOfCounters,            "CFG_OsClkPolarityOfCounters",
   CFG_OsGatePolarityOfCounters,           "CFG_OsGatePolarityOfCounters",
   CFG_OsOutSignalOfCounters,              "CFG_OsOutSignalOfCounters",
   CFG_FeatureTmrGateControlOfCounters,    "CFG_FeatureTmrGateControlOfCounters",
   CFG_FeatureTmrGatePolarities,           "CFG_FeatureTmrGatePolarities",
   CFG_FeatureTmrOutSignals,               "CFG_FeatureTmrOutSignals",
   CFG_FeatureTmrFrequencyRange,           "CFG_FeatureTmrFrequencyRange",
   CFG_TmrGateEnabledOfCounters,           "CFG_TmrGateEnabledOfCounters",
   CFG_TmrGatePolarityOfCounters,          "CFG_TmrGatePolarityOfCounters",
   CFG_TmrOutSignalOfCounters,             "CFG_TmrOutSignalOfCounters",
   CFG_FeaturePoGateControlOfCounters,     "CFG_FeaturePoGateControlOfCounters",
   CFG_FeaturePoGatePolarities,            "CFG_FeaturePoGatePolarities",
   CFG_FeaturePoHiPeriodRange,             "CFG_FeaturePoHiPeriodRange",
   CFG_FeaturePoLoPeriodRange,             "CFG_FeaturePoLoPeriodRange",
   CFG_FeaturePoOutCountRange,             "CFG_FeaturePoOutCountRange",
   CFG_PoGateEnabledOfCounters,            "CFG_PoGateEnabledOfCounters",
   CFG_PoGatePolarityOfCounters,           "CFG_PoGatePolarityOfCounters",
   CFG_PoOutCountOfCounters,               "CFG_PoOutCountOfCounters",
   CFG_FeatureChipClkPolarities,           "CFG_FeatureChipClkPolarities",
   CFG_FeatureChipGatePolarities,          "CFG_FeatureChipGatePolarities",
   CFG_FeatureChipOutSignals,              "CFG_FeatureChipOutSignals",
   CFG_ChipClkPolarityOfCounters,          "CFG_ChipClkPolarityOfCounters",
   CFG_ChipGatePolarityOfCounters,         "CFG_ChipGatePolarityOfCounters",
   CFG_ChipOutSignalOfCounters,            "CFG_ChipOutSignalOfCounters",
   CFG_FeatureOsDelayCountRange,           "CFG_FeatureOsDelayCountRange",
   CFG_FeatureUdCountingTypes,             "CFG_FeatureUdCountingTypes",
   CFG_FeatureUdInitialValues,             "CFG_FeatureUdInitialValues",
   CFG_UdCountingTypeOfCounters,           "CFG_UdCountingTypeOfCounters",
   CFG_UdInitialValueOfCounters,           "CFG_UdInitialValueOfCounters",
   CFG_UdCountValueResetTimesByIndexs,     "CFG_UdCountValueResetTimesByIndexs",
   CFG_FeatureFilterTypes,                 "CFG_FeatureFilterTypes",
   CFG_FeatureFilterCutoffFreqRange,       "CFG_FeatureFilterCutoffFreqRange", 
   CFG_FeatureFilterCutoffFreq1Range,      "CFG_FeatureFilterCutoffFreq1Range",
   CFG_FilterTypeOfChannels,               "CFG_FilterTypeOfChannels", 
   CFG_FilterCutoffFreqOfChannels,         "CFG_FilterCutoffFreqOfChannels", 
   CFG_FilterCutoffFreq1OfChannels,        "CFG_FilterCutoffFreq1OfChannels"
};

int Type_PropertyID::count = TYPE_RPOPERTYID;

char* Type_PropertyID::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_PropertyID::count; ++i)
    {
        if (Type_PropertyID::content[i].iID == id)
        {
            return Type_PropertyID::content[i].strSpec;
        }
    }
    return "undefine ID";
}


int Type_PropertyID::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_PropertyID::count; ++i)
    {
        if (0 == strcmp(caption, Type_PropertyID::content[i].strSpec))
        {
            return Type_PropertyID::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_PropertyDataType::content[TYPE_PROPERTYDATATYPE] = {
    _INT_,          "INT",
    _LONG_,         "LONG",
    _ULONG_,        "ULONG",
    _DOUBLE_,       "DOUBLE",
    _MATHINTERVAL_, "MATHINTERVAL",
    _BYTE_ARRAY_,   "BYTE_ARRAY",
    _LONG_ARRAY_,   "LONG_ARRAY",
    _ULONG_ARRAY_,  "ULONG_ARRAY",
    _DOUBLE_ARRAY_, "DOUBLE_ARRAY",
    _WCHAR_ARRAY_,  "WCHAR_ARRAY",
    _BOOL_, "BOOL"
};

int Type_PropertyDataType::count = TYPE_PROPERTYDATATYPE;

char* Type_PropertyDataType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_PropertyDataType::count; ++i)
    {
        if (Type_PropertyDataType::content[i].iID == id)
        {
            return Type_PropertyDataType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_PropertyDataType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_PropertyDataType::count; ++i)
    {
        if (0 == strcmp(caption,Type_PropertyDataType::content[i].strSpec))
        {
            return Type_PropertyDataType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_SubCtrlType::content[TYPE_SUBCTRLTYPE] = {
    _AnalogInputChannel_,          "AnalogInputChannel"       
};

int Type_SubCtrlType::count = TYPE_SUBCTRLTYPE;

char* Type_SubCtrlType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_SubCtrlType::count; ++i)
    {
        if (Type_SubCtrlType::content[i].iID == id)
        {
            return Type_SubCtrlType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_SubCtrlType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_SubCtrlType::count; ++i)
    {
        if (0 == strcmp(caption,Type_SubCtrlType::content[i].strSpec))
        {
            return Type_SubCtrlType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////
SPEC_PROPERTY Type_EnumType::content[TYPE_ENUMTYPE] = {
    _NotaEnumValue,         "NotaEnumValue",
    _TerminalBoard,         "TerminalBoard",
    _ModuleType,            "ModuleType",
    _AccessMode,            "AccessMode",
    _MathIntervalType,      "MathIntervalType",
    _AiChannelType,         "AiChannelType",
    _AiSignalType,          "AiSignalType",
    _DioPortType,           "DioPortType",
    _DioPortDir,            "DioPortDir",
    _SamplingMethod,        "SamplingMethod",
    _TemperatureDegree,     "TemperatureDegree",
    _BurnoutRetType,        "BurnoutRetType",
    _ValueUnit,             "ValueUnit",
    _ValueRange,            "ValueRange",
    _SignalPolarity,        "SignalPolarity",
    _SignalCountingType,    "SignalCountingType",
    _OutSignalType,         "OutSignalType",
    _CounterCapability,     "CounterCapability",
    _CounterOperationMode,  "CounterOperationMode",
    _CounterValueRegister,  "CounterValueRegister",
    _CounterCascadeGroup,   "CounterCascadeGroup",
    _FreqMeasureMethod,     "FreqMeasureMethod",
    _ActiveSignal,          "ActiveSignal",
    _TriggerAction,         "TriggerAction",
    _SignalPosition,        "SignalPosition",
    _SignalDrop,            "SignalDrop",
    _EventId,               "EventId",
    _PropertyAttribute,     "PropertyAttribute",
    _PropertyId,            "PropertyId",
    _ProductId,             "ProductId",
    _FilterType,            "FilterType",
    _BOOL,                  "BOOL",
};

int Type_EnumType::count = TYPE_ENUMTYPE;

char* Type_EnumType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_EnumType::count; ++i)
    {
        if (Type_EnumType::content[i].iID == id)
        {
            return Type_EnumType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_EnumType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_EnumType::count; ++i)
    {
        if (0 == strcmp(caption,Type_EnumType::content[i].strSpec))
        {
            return Type_EnumType::content[i].iID;
        }
    }
    return -1;
}

//////////////////////////////////////////////
bool PropertyTransHelper::GetPropertyEnumType(int id, int& datatypeid, int& enumtypeid)
{
    bool _b_success = true;
    switch (id)
    {
    case CFG_Number:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ComponentType:
        {
            datatypeid = _LONG_;
            enumtypeid = _ModuleType;
        }
        break;
    case CFG_Description:
        {
            datatypeid = _WCHAR_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_Parent:
        {
            datatypeid = _LONG_;
            enumtypeid = _ModuleType;
        }
        break;
    case CFG_ChildList:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _ModuleType;
        }
        break;
    case CFG_DevicesNumber:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DevicesHandle:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceGroupNumber:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceProductID:
        {
            datatypeid = _ULONG_;
            enumtypeid = _ProductId;
        }
        break;
    case CFG_DeviceBoardID:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceBoardVersion:
        {
            datatypeid = _WCHAR_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceDriverVersion:
        {
            datatypeid = _WCHAR_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceDllVersion:
        {
            datatypeid = _WCHAR_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceLocation: 
        {
            datatypeid = _WCHAR_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceBaseAddresses:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceInterrupts:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceSupportedTerminalBoardTypes: 
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceTerminalBoardType:  
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceHotResetPreventable:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceLoadingTimeInit: 
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceWaitingForReconnect:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceWaitingForSleep:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureResolutionInBit:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDataSize:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDataMask:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureChannelNumberMax:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureChannelConnectionType:
        {
            datatypeid = _ULONG_;
            enumtypeid = _AiChannelType;
        }
        break;
    case CFG_FeatureBurnDetectedReturnTypes:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    //have been deleted!
    case CFG_FeatureBurnoutDetectionChannels:
        break;
    case CFG_FeatureOverallVrgType:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureVrgTypes:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _ValueRange;
        }
        break;
    case CFG_FeatureExtRefRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureExtRefAntiPolar:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureCjcChannels:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureChannelScanMethod:
        {
            datatypeid = _ULONG_;
            enumtypeid = _SamplingMethod;
        }
        break;
    case CFG_FeatureScanChannelStartBase:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureScanChannelCountBase:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureConvertClockSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureConvertClockRateRange: 
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureScanClockSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureScanClockRateRange: 
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureScanCountMax:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureTriggersCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureTriggerSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureTriggerActions:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_FeatureTriggerDelayCountRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureTriggerSources1:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureTriggerActions1:  
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_FeatureTriggerDelayCountRange1:  
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_ChannelCount:
        { 
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ConnectionTypeOfChannels:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _AiSignalType;
        }
        break;
    case CFG_VrgTypeOfChannels:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _ValueRange;
        }
        break;
    case CFG_BurnDetectedReturnTypeOfChannels:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_BurnoutReturnValueOfChannels:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ExtRefValueForUnipolar: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ExtRefValueForBipolar:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_CjcChannel:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_CjcUpdateFrequency: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_CjcValue:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_SectionDataCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ConvertClockSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_ConvertClockRatePerChannel:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ScanChannelStart:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ScanChannelCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ScanClockSource: 
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_ScanClockRate: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ScanCount: 
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TriggerSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_TriggerSourceEdge:
        {
            datatypeid = _ULONG_;
            enumtypeid = _ActiveSignal;
        }
        break;
    case CFG_TriggerSourceLevel:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TriggerDelayCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TriggerAction:
        {
            datatypeid = _ULONG_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_TriggerSource1:  
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_TriggerSourceEdge1:
        {
            datatypeid = _ULONG_;
            enumtypeid = _ActiveSignal;
        }
        break;
    case CFG_TriggerSourceLevel1: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TriggerDelayCount1: 
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TriggerAction1:  
        {
            datatypeid = _ULONG_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_ParentSignalConnectionChannel:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ParentCjcConnectionChannel:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ParentControlPort:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeaturePortsCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeaturePortsType:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _DioPortType;
        }
        break;
    
        
    case CFG_FeatureDiintTriggerEdges:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiintOfChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiintGateOfChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiCosintOfChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiPmintOfChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    
    //case CFG_FeatureDiSnapEventSources: 
    //case CFG_FeatureSnapEventSources: 
    case CFG_FeatureDoFreezeSignalSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDoReflectWdtFeedIntervalRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureDiPortScanMethod: 
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiConvertClockSources: 
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDiConvertClockRateRange: 
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureDiScanClockSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDiScanClockRateRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureDiScanCountMax:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiTriggersCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDiTriggerSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDiTriggerActions:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_FeatureDiTriggerDelayCountRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureDiTriggerSources1:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDiTriggerActions1:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_FeatureDiTriggerDelayCountRange1:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;              
    case CFG_FeatureDoConvertClockSources: 
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDoConvertClockRateRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break; 
    case CFG_FeatureDoScanClockSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDoScanClockRateRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break; 
    case CFG_FeatureDoScanCountMax:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDoTriggersCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureDoTriggerSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDoTriggerActions:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_FeatureDoTriggerDelayCountRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break; 
    case CFG_FeatureDoTriggerSources1:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureDoTriggerActions1:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_FeatureDoTriggerDelayCountRange1:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break; 
    case CFG_DirectionOfPorts:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _DioPortDir;
        }
        break;
    case CFG_DiDataMaskOfPorts:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoDataMaskOfPorts:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;           
    case CFG_DiintTriggerEdgeOfChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _ActiveSignal;
        }
        break; 
    case CFG_DiintGateEnabledChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break; 
    case CFG_DiCosintEnabledChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break; 
    case CFG_DiPmintEnabledChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break; 
    case CFG_DiPmintValueOfPorts:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break; 
    case CFG_DoInitialStateOfPorts:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoFreezeEnabled:  
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoFreezeSignalState:  
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoReflectWdtFeedInterval:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoReflectWdtLockValue:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiSectionDataCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiConvertClockSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DiConvertClockRatePerPort:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiScanPortStart:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiScanPortCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiScanClockSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DiScanClockRate:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiScanCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiTriggerAction:
        {
            datatypeid = _ULONG_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_DiTriggerSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DiTriggerSourceEdge:
        {
            datatypeid = _LONG_;
            enumtypeid = _ActiveSignal;
        }
        break;
    case CFG_DiTriggerSourceLevel:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiTriggerDelayCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiTriggerAction1:
        {
            datatypeid = _ULONG_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_DiTriggerSource1:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DiTriggerSourceEdge1:
        {
            datatypeid = _LONG_;
            enumtypeid = _ActiveSignal;
        }
        break;
    case CFG_DiTriggerSourceLevel1: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DiTriggerDelayCount1:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoSectionDataCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoConvertClockSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DoConvertClockRatePerPort:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoScanPortStart:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoScanPortCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoScanClockSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DoScanClockRate:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoScanCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoTriggerAction:
        {
            datatypeid = _ULONG_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_DoTriggerSource:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DoTriggerSourceEdge:
        {
            datatypeid = _LONG_;
            enumtypeid = _ActiveSignal;
        }
        break;
    case CFG_DoTriggerSourceLevel: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoTriggerDelayCount:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoTriggerAction1:
        {
            datatypeid = _ULONG_;
            enumtypeid = _TriggerAction;
        }
        break;
    case CFG_DoTriggerSource1:
        {
            datatypeid = _LONG_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_DoTriggerSourceEdge1:
        {
            datatypeid = _LONG_;
            enumtypeid = _ActiveSignal;
        }
        break;
    case CFG_DoTriggerSourceLevel1: 
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DoTriggerDelayCount1:
        {
            datatypeid = _ULONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter0:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter1:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter2:
        {
            datatypeid = _ULONG_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter3:
        {
            datatypeid = _ULONG_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter4:
        {
            datatypeid = _ULONG_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter5:
        {
            datatypeid = _ULONG_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter6:
        {
            datatypeid = _ULONG_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureCapabilitiesOfCounter7:
        {
            datatypeid = _ULONG_;
            enumtypeid = _CounterCapability;
        }
        break;
    case CFG_FeatureChipOperationModes :
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _CounterOperationMode;
        }
        break;
    case CFG_FeatureChipSignalCountingTypes:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalCountingType;
        }
        break;
    case CFG_FeatureTmrCascadeGroups :
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _CounterCascadeGroup;
        }
        break;
    case CFG_FeatureFmMethods:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _FreqMeasureMethod;
        }
        break;
    case CFG_ChipOperationModeOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _CounterOperationMode;
        }
        break;
    
    case CFG_ChipLoadValueOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ChipHoldValueOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ChipOverCompareValueOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    
    case CFG_ChipOverCompareEnabledCounters:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ChipUnderCompareEnabledCounters:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FmMethodOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _FreqMeasureMethod;
        }
        break;
    case CFG_FmCollectionPeriodOfCounters:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DevicePrivateRegionLength:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_SaiAutoConvertClockRate:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_SaiAutoConvertChannelStart:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_SaiAutoConvertChannelCount:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ExtPauseSignalEnabled:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ExtPauseSignalPolarity:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_OrderOfChannels:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_InitialStateOfChannels:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter0:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter1:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter2:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter3:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter4:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter5:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter6:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipClkSourceOfCounter7:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter0:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter1:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter2:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter3:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter4:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter5:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter6:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipGateSourceOfCounter7:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureChipValueRegisters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _CounterValueRegister;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter0:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter1:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter2:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter3:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter4:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter5:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter6:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsClkSourceOfCounter7:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter0:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter1:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter2:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter3:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter4:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter5:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter6:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_FeatureOsGateSourceOfCounter7:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;  
    case CFG_ChipClkSourceOfCounters: 
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_ChipGateSourceOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_OsClkSourceOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_OsGateSourceOfCounters:
        {
            datatypeid = _ULONG_ARRAY_;
            enumtypeid = _SignalDrop;
        }
        break;
    case CFG_OsDelayCountOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TmrFrequencyOfCounters:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_PoHiPeriodOfCounters:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_PoLoPeriodOfCounters:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureEcClkPolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureEcGatePolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureEcGateControlOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_EcClkPolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_EcGatePolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_EcGateEnabledOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureOsClkPolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureOsGatePolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureOsOutSignals:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _OutSignalType;
        }
        break;
    case CFG_OsClkPolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_OsGatePolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_OsOutSignalOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _OutSignalType;
        }
        break;
    case CFG_FeatureTmrGateControlOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureTmrGatePolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureTmrOutSignals:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _OutSignalType;
        }
        break;
    case CFG_FeatureTmrFrequencyRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_TmrGateEnabledOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_TmrGatePolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_TmrOutSignalOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _OutSignalType;
        }
        break;
    case CFG_FeaturePoGateControlOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeaturePoGatePolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeaturePoHiPeriodRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeaturePoLoPeriodRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeaturePoOutCountRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_PoGateEnabledOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_PoGatePolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_PoOutCountOfCounters:
        {
            datatypeid = _LONG_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureChipClkPolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureChipGatePolarities:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_FeatureChipOutSignals:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _OutSignalType;
        }
        break;
    case CFG_ChipClkPolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_ChipGatePolarityOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalPolarity;
        }
        break;
    case CFG_ChipOutSignalOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _OutSignalType;
        }
        break;
    case CFG_FeatureNoiseFilterOfChannels: 
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FeatureNoiseFilterBlockTimeRange: 
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureSnapEventSources:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _EventId;
        }
        break;
    case CFG_NoiseFilterOverallBlockTime:
        {
            datatypeid = _DOUBLE_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_NoiseFilterEnabledChannels:
        {
            datatypeid = _BYTE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_ChipSignalCountingTypeOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalCountingType;
        }
        break;
    case CFG_FeatureOsDelayCountRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureUdCountingTypes:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalCountingType;
        }
        break;
    case CFG_FeatureUdInitialValues:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_UdCountingTypeOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _SignalCountingType;
        }
        break;   
    case CFG_UdInitialValueOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_UdCountValueResetTimesByIndexs:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_DeviceSupportedEvents: 
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _EventId;
        }
        break;
    case CFG_FeaturePiCascadeGroups:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _CounterCascadeGroup;
        }
        break;
    case CFG_ChipUnderCompareValueOfCounters:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;

    case CFG_FeatureFilterTypes:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _FilterType;
        }
        break;
    case CFG_FeatureFilterCutoffFreqRange:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FeatureFilterCutoffFreq1Range:
        {
            datatypeid = _MATHINTERVAL_;
            enumtypeid = _MathIntervalType;
        }
        break;
    case CFG_FilterTypeOfChannels:
        {
            datatypeid = _LONG_ARRAY_;
            enumtypeid = _FilterType;
        }
        break;
    case CFG_FilterCutoffFreqOfChannels:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;
    case CFG_FilterCutoffFreq1OfChannels:
        {
            datatypeid = _DOUBLE_ARRAY_;
            enumtypeid = _NotaEnumValue;
        }
        break;

    //Not list in the document!!!!
    case CFG_FeatureDoPortScanMethod:  
        _b_success = false;
        break;
    default:
        _b_success = false;
        break;
    }
    return _b_success;
}

bool PropertyTransHelper::GetPropertyDetail(int id, BIO_DEV_PROPERTY_DETAIL& detail, InfoTransLastError& error_info)
{
    bool _b_success = true;
    error_info = TRANS_SUCCESS;
    detail.name = Type_PropertyID::GetPropertySpec(id);
	detail.id = id;
    if (0 == strcmp("undefine ID", detail.name))
    {
        error_info = PROPERTY_ID_ERROR;
        _b_success = false;
    }
    else
    {
        _b_success = PropertyTransHelper::GetPropertyEnumType(id, detail.datatypeid, detail.enumtypeid);
        if (!_b_success)
        {
            error_info = DATATYPE_ERROR;
            _b_success = false;
        }
        else
        {
            detail.datatypename = Type_PropertyDataType::GetPropertySpec(detail.datatypeid);
            detail.enumtypename = Type_EnumType::GetPropertySpec(detail.enumtypeid);
        }    
    } 
    return _b_success;
}

void PropertyTransHelper::GetEnumTypeValueString(int enumtype, int enumvalue, char** outcharvalue)
{
    if (enumtype != _NotaEnumValue)
    {
        switch (enumtype)
        {
        case _NotaEnumValue:
            {
                *outcharvalue = NULL;
            }
            break;
        case _TerminalBoard:
            {
                *outcharvalue = Type_TerminalBoard::GetPropertySpec(enumvalue);
            }
            break;
        case _ModuleType:
            {
                *outcharvalue = Type_ModuleType::GetPropertySpec(enumvalue);
            }
            break;
        case _AccessMode:
            {
                *outcharvalue = Type_AccessMode::GetPropertySpec(enumvalue);
            }
            break;
        case _MathIntervalType:
            {
                *outcharvalue = Type_MathIntervalType::GetPropertySpec(enumvalue);
            }
            break;
        case _AiChannelType:
            {
                *outcharvalue = Type_AiChannelType::GetPropertySpec(enumvalue);
            }
            break;
        case _AiSignalType:
            {
                *outcharvalue = Type_AiSignalType::GetPropertySpec(enumvalue);
            }
            break;
        case _FilterType:
            {
                *outcharvalue = Type_FilterType::GetPropertySpec(enumvalue);
            }
            break;
        case _DioPortType:
            {
                *outcharvalue = Type_DioPortType::GetPropertySpec(enumvalue);
            }
            break;
        case _DioPortDir:
            {
                *outcharvalue = Type_DioPortDir::GetPropertySpec(enumvalue);
            }
            break;
        case _SamplingMethod:
            {
                *outcharvalue = Type_SamplingMethod::GetPropertySpec(enumvalue);
            }
            break;
        case _TemperatureDegree:
            {
                *outcharvalue = Type_TemperatureDegree::GetPropertySpec(enumvalue);
            }
            break;
        case _BurnoutRetType:
            {
                *outcharvalue = Type_BurnoutRetType::GetPropertySpec(enumvalue);
            }
            break;
        case _ValueUnit:
            {
                *outcharvalue = Type_ValueUnit::GetPropertySpec(enumvalue);
            }
            break;
        case _ValueRange:
            {
                *outcharvalue = Type_ValueRange::GetPropertySpec(enumvalue);
            }
            break;
        case _SignalPolarity:
            {
                *outcharvalue = Type_SignalPolarity::GetPropertySpec(enumvalue);
            }
            break;
        case _SignalCountingType:
            {
                *outcharvalue = Type_SignalCountingType::GetPropertySpec(enumvalue);
            }
            break;
        case _OutSignalType:
            {
                *outcharvalue = Type_OutSignalType::GetPropertySpec(enumvalue);
            }
            break;
        case _CounterCapability:
            {
                *outcharvalue = Type_CounterCapability::GetPropertySpec(enumvalue);
            }
            break;
        case _CounterOperationMode:
            {
                *outcharvalue = Type_CounterOperationMode::GetPropertySpec(enumvalue);
            }
            break;
        case _CounterValueRegister:
            {
                *outcharvalue = Type_CounterValueRegister::GetPropertySpec(enumvalue);
            }
            break;
        case _CounterCascadeGroup:
            {
                *outcharvalue = Type_CounterCascadeGroup::GetPropertySpec(enumvalue);
            }
            break;
        case _FreqMeasureMethod:
            {
                *outcharvalue = Type_FreqMeasureMethod::GetPropertySpec(enumvalue);
            }
            break;
        case _ActiveSignal:
            {
                *outcharvalue = Type_ActiveSignal::GetPropertySpec(enumvalue);
            }
            break;
        case _TriggerAction:
            {
                *outcharvalue = Type_TriggerAction::GetPropertySpec(enumvalue);
            }
            break;
        case _SignalPosition:
            {
                *outcharvalue = Type_SignalPosition::GetPropertySpec(enumvalue);
            }
            break;
        case _SignalDrop:
            {
                *outcharvalue = Type_SignalDrop::GetPropertySpec(enumvalue);
            }
            break;
        case _EventId:
            {
                *outcharvalue = Type_EventId::GetPropertySpec(enumvalue);
            }
            break;
        case _PropertyAttribute:
            {
                *outcharvalue = Type_PropertyAttribute::GetPropertySpec(enumvalue);
            }
            break;
        case _PropertyId:
            {
                *outcharvalue = Type_PropertyID::GetPropertySpec(enumvalue);
            }
            break;
        case _ProductId:
            {
                *outcharvalue = Type_ProductId::GetPropertySpec(enumvalue);
            }
            break;
        case _BOOL:
            {
                *outcharvalue = Type_Bool::GetPropertySpec(enumvalue);
            }
            break;
        default:
            {
                *outcharvalue = NULL;
            }
            break;
        }
    }
}

SPEC_PROPERTY PropertyTransHelper::content[TYPE_INFOTRANSLATERROR] = {
    TRANS_SUCCESS,      "TRANS_SUCCESS",
    PROPERTY_ID_ERROR,  "PROPERTY_ID_ERROR",
    DATATYPE_ERROR,     "DATATYPE_ERROR",
    ACCESSABLE_ERROR,   "ACCESSABLE_ERROR",
    LENGTH_ERROR,	    "LENGTH_ERROR"	
};

int PropertyTransHelper::count = TYPE_INFOTRANSLATERROR;

char* PropertyTransHelper::GetPropertySpec(int id)
{
    for (int i = 0; i < PropertyTransHelper::count; ++i)
    {
        if (PropertyTransHelper::content[i].iID == id)
        {
            return PropertyTransHelper::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int PropertyTransHelper::GetPropertyID(char* caption)
{
    for (int i = 0; i < PropertyTransHelper::count; ++i)
    {
        if (0 == strcmp(caption, PropertyTransHelper::content[i].strSpec))
        {
            return PropertyTransHelper::content[i].iID;
        }
    }
    return -1;
}

void PropertyTransHelper::ListAllEnumValue(int enumtypeid, char* pfilename)
{
    switch (enumtypeid)
    {
    case _TerminalBoard:
        {
            for (int i = 0; i < Type_TerminalBoard::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_TerminalBoard::content[i].strSpec);
            }
        }
        break;
    case _ModuleType:
        {
            for (int i = 0; i < Type_ModuleType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_ModuleType::content[i].strSpec);
            }
        }
        break;
    case _AccessMode:
        {
            for (int i = 0; i < Type_AccessMode::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_AccessMode::content[i].strSpec);
            }
        }
        break;
    case _MathIntervalType:
        {
            for (int i = 0; i < Type_MathIntervalType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_MathIntervalType::content[i].strSpec);
            }
        }
        break;
    case _AiChannelType:
        {
            for (int i = 0; i < Type_AiChannelType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_AiChannelType::content[i].strSpec);
            }
        }
        break;
    case _AiSignalType:
        {
            for (int i = 0; i < Type_AiSignalType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_AiSignalType::content[i].strSpec);
            }
        }
        break;
    case _FilterType:
        {
            for (int i = 0; i < Type_FilterType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_FilterType::content[i].strSpec);
            }
        }
        break;
    case _DioPortType:
        {
            for (int i = 0; i < Type_DioPortType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_DioPortType::content[i].strSpec);
            }
        }
        break;
    case _DioPortDir:
        {
            for (int i = 0; i < Type_DioPortDir::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_DioPortDir::content[i].strSpec);
            }
        }
        break;
    case _SamplingMethod:
        {
            for (int i = 0; i < Type_SamplingMethod::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_SamplingMethod::content[i].strSpec);
            }
        }
        break;
    case _TemperatureDegree:
        {
            for (int i = 0; i < Type_TemperatureDegree::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_TemperatureDegree::content[i].strSpec);
            }
        }
        break;
    case _BurnoutRetType:
        {
            for (int i = 0; i < Type_BurnoutRetType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_BurnoutRetType::content[i].strSpec);
            }
        }
        break;
    case _ValueUnit:
        {
            for (int i = 0; i < Type_ValueUnit::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_ValueUnit::content[i].strSpec);
            }
        }
        break;
    case _ValueRange:
        {
            for (int i = 0; i < Type_ValueRange::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_ValueRange::content[i].strSpec);
            }
        }
        break;
    case _SignalPolarity:
        {
            for (int i = 0; i < Type_SignalPolarity::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_SignalPolarity::content[i].strSpec);
            }
        }
        break;
    case _SignalCountingType:
        {
            for (int i = 0; i < Type_SignalCountingType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_SignalCountingType::content[i].strSpec);
            }
        }
        break;
    case _OutSignalType:
        {
            for (int i = 0; i < Type_OutSignalType::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_OutSignalType::content[i].strSpec);
            }
        }
        break;
    case _CounterCapability:
        {
            for (int i = 0; i < Type_CounterCapability::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_CounterCapability::content[i].strSpec);
            }
        }
        break;
    case _CounterOperationMode:
        {
            for (int i = 0; i < Type_CounterOperationMode::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_CounterOperationMode::content[i].strSpec);
            }
        }
        break;
    case _CounterValueRegister:
        {
            for (int i = 0; i < Type_CounterValueRegister::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_CounterValueRegister::content[i].strSpec);
            }
        }
        break;
    case _CounterCascadeGroup:
        {
            for (int i = 0; i < Type_CounterCascadeGroup::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_CounterCascadeGroup::content[i].strSpec);
            }
        }
        break;
    case _FreqMeasureMethod:
        {
            for (int i = 0; i < Type_FreqMeasureMethod::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_FreqMeasureMethod::content[i].strSpec);
            }
        }
        break;
    case _ActiveSignal:
        {
            for (int i = 0; i < Type_ActiveSignal::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_ActiveSignal::content[i].strSpec);
            }
        }
        break;
    case _TriggerAction:
        {
            for (int i = 0; i < Type_TriggerAction::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_TriggerAction::content[i].strSpec);
            }
        }
        break;
    case _SignalPosition:
        {
            for (int i = 0; i < Type_SignalPosition::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_SignalPosition::content[i].strSpec);
            }
        }
        break;
    case _SignalDrop:
        {
            for (int i = 0; i < Type_SignalDrop::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_SignalDrop::content[i].strSpec);
                if (NULL != pfilename)
                {
                    char psz_out[256] = {0};
                    sprintf(psz_out, "%3d. %s\r\n", i + 1, Type_SignalDrop::content[i].strSpec);
                    WriteStringToFile(pfilename, psz_out, strlen(psz_out));
                }
            }
        }
        break;
    case _EventId:
        {
            for (int i = 0; i < Type_EventId::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_EventId::content[i].strSpec);
            }
        }
        break;
    case _PropertyAttribute:
        {
            for (int i = 0; i < Type_PropertyAttribute::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_PropertyAttribute::content[i].strSpec);
            }
        }
        break;
    case _PropertyId:
        {
            for (int i = 0; i < Type_PropertyID::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_PropertyID::content[i].strSpec);
            }
        }
        break;
    case _ProductId:
        {
            for (int i = 0; i < Type_ProductId::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_ProductId::content[i].strSpec);
            }
        }
        break;
    case _BOOL:
        {
            for (int i = 0; i < Type_Bool::count; ++i)
            {
                printf("%3d. %s\n", i + 1, Type_Bool::content[i].strSpec);
            }
        }
        break;
    case _NotaEnumValue:
    default:
        printf("The property id input is not a enumb type!\n");
        break;
    }
}

int PropertyTransHelper::GetSpecEnumValueFromIndex(int enumtypeid, int index)
{
    int enumvalue = -1;
    if (index < -1)
    {
        return enumvalue;
    }
    switch (enumtypeid)
    {
    case _TerminalBoard:
        if (index <= Type_TerminalBoard::count)
        {
            enumvalue = Type_TerminalBoard::content[index].iID;
        }  
        break;
    case _ModuleType:
        if (index <= Type_ModuleType::count)
        {
            enumvalue = Type_ModuleType::content[index].iID;
        }
        break;
    case _AccessMode:
        if (index <= Type_AccessMode::count)
        {
            enumvalue = Type_AccessMode::content[index].iID;
        }
        break;
    case _MathIntervalType:
        if (index <= Type_MathIntervalType::count)
        {
            enumvalue = Type_MathIntervalType::content[index].iID;
        }
        break;
    case _AiChannelType:
        if (index <= Type_AiChannelType::count)
        {
            enumvalue = Type_AiChannelType::content[index].iID;
        }
        break;
    case _AiSignalType:
        if (index <= Type_AiSignalType::count)
        {
            enumvalue = Type_AiSignalType::content[index].iID;
        }
        break;
    case _FilterType:
        if (index <= Type_FilterType::count)
        {
            enumvalue = Type_FilterType::content[index].iID;
        }
        break;
    case _DioPortType:
        if (index <= Type_DioPortType::count)
        {
            enumvalue = Type_DioPortType::content[index].iID;
        }
        break;
    case _DioPortDir:
        if (index <= Type_DioPortDir::count)
        {
            enumvalue = Type_DioPortDir::content[index].iID;
        }
        break;
    case _SamplingMethod:
        if (index <= Type_SamplingMethod::count)
        {
            enumvalue = Type_SamplingMethod::content[index].iID;
        }
        break;
    case _TemperatureDegree:
        if (index <= Type_TemperatureDegree::count)
        {
            enumvalue = Type_TemperatureDegree::content[index].iID;
        }
        break;
    case _BurnoutRetType:
        if (index <= Type_BurnoutRetType::count)
        {
            enumvalue = Type_BurnoutRetType::content[index].iID;
        }
        break;
    case _ValueUnit:
        if (index <= Type_ValueUnit::count)
        {
            enumvalue = Type_ValueUnit::content[index].iID;
        }
        break;
    case _ValueRange:
        if (index <= Type_ValueRange::count)
        {
            enumvalue = Type_ValueRange::content[index].iID;
        }
        break;
    case _SignalPolarity:
        if (index <= Type_SignalPolarity::count)
        {
            enumvalue = Type_SignalPolarity::content[index].iID;
        }
        break;
    case _SignalCountingType:
        if (index <= Type_SignalCountingType::count)
        {
            enumvalue = Type_SignalCountingType::content[index].iID;
        }
        break;
    case _OutSignalType:
        if (index <= Type_OutSignalType::count)
        {
            enumvalue = Type_OutSignalType::content[index].iID;
        }
        break;
    case _CounterCapability:
        if (index <= Type_CounterCapability::count)
        {
            enumvalue = Type_CounterCapability::content[index].iID;
        }
        break;
    case _CounterOperationMode:
        if (index <= Type_CounterOperationMode::count)
        {
            enumvalue = Type_CounterOperationMode::content[index].iID;
        }
        break;
    case _CounterValueRegister:
        if (index <= Type_CounterValueRegister::count)
        {
            enumvalue = Type_CounterValueRegister::content[index].iID;
        }
        break;
    case _CounterCascadeGroup:
        if (index <= Type_CounterCascadeGroup::count)
        {
            enumvalue = Type_CounterCascadeGroup::content[index].iID;
        }
        break;
    case _FreqMeasureMethod:
        if (index <= Type_FreqMeasureMethod::count)
        {
            enumvalue = Type_FreqMeasureMethod::content[index].iID;
        }
        break;
    case _ActiveSignal:
        if (index <= Type_ActiveSignal::count)
        {
            enumvalue = Type_ActiveSignal::content[index].iID;
        }
        break;
    case _TriggerAction:
        if (index <= Type_TriggerAction::count)
        {
            enumvalue = Type_TriggerAction::content[index].iID;
        }
        break;
    case _SignalPosition:
        if (index <= Type_SignalPosition::count)
        {
            enumvalue = Type_SignalPosition::content[index].iID;
        }
        break;
    case _SignalDrop:
        if (index <= Type_SignalDrop::count)
        {
            enumvalue = Type_SignalDrop::content[index].iID;
        }
        break;
    case _EventId:
        if (index <= Type_EventId::count)
        {
            enumvalue = Type_EventId::content[index].iID;
        }
        break;
    case _PropertyAttribute:
        if (index <= Type_PropertyAttribute::count)
        {
            enumvalue = Type_PropertyAttribute::content[index].iID;
        }
        break;
    case _PropertyId:
        if (index <= Type_PropertyID::count)
        {
            enumvalue = Type_PropertyID::content[index].iID;
        }
        break;
    case _ProductId:
        if (index <= Type_ProductId::count)
        {
            enumvalue = Type_ProductId::content[index].iID;
        }
        break;
    case _BOOL:
        if (index <= Type_Bool::count)
        {
            enumvalue = Type_Bool::content[index].iID;
        }
        break;
    case _NotaEnumValue:
    default:
        printf("The property id input is not a enumb type!\n");
        break;
    }
    return enumvalue;
}

char* PropertyTransHelper::GetSpecEnumStringFromIndex(int enumtypeid, int index)
{
    char* enumvalue = NULL;
    if (index < -1)
    {
        return enumvalue;
    }
    switch (enumtypeid)
    {
    case _TerminalBoard:
        if (index <= Type_TerminalBoard::count)
        {
            enumvalue = Type_TerminalBoard::content[index].strSpec;
        }  
        break;
    case _ModuleType:
        if (index <= Type_ModuleType::count)
        {
            enumvalue = Type_ModuleType::content[index].strSpec;
        }
        break;
    case _AccessMode:
        if (index <= Type_AccessMode::count)
        {
            enumvalue = Type_AccessMode::content[index].strSpec;
        }
        break;
    case _MathIntervalType:
        if (index <= Type_MathIntervalType::count)
        {
            enumvalue = Type_MathIntervalType::content[index].strSpec;
        }
        break;
    case _AiChannelType:
        if (index <= Type_AiChannelType::count)
        {
            enumvalue = Type_AiChannelType::content[index].strSpec;
        }
        break;
    case _AiSignalType:
        if (index <= Type_AiSignalType::count)
        {
            enumvalue = Type_AiSignalType::content[index].strSpec;
        }
        break;
    case _FilterType:
        if (index <= Type_FilterType::count)
        {
            enumvalue = Type_FilterType::content[index].strSpec;
        }
        break;
    case _DioPortType:
        if (index <= Type_DioPortType::count)
        {
            enumvalue = Type_DioPortType::content[index].strSpec;
        }
        break;
    case _DioPortDir:
        if (index <= Type_DioPortDir::count)
        {
            enumvalue = Type_DioPortDir::content[index].strSpec;
        }
        break;
    case _SamplingMethod:
        if (index <= Type_SamplingMethod::count)
        {
            enumvalue = Type_SamplingMethod::content[index].strSpec;
        }
        break;
    case _TemperatureDegree:
        if (index <= Type_TemperatureDegree::count)
        {
            enumvalue = Type_TemperatureDegree::content[index].strSpec;
        }
        break;
    case _BurnoutRetType:
        if (index <= Type_BurnoutRetType::count)
        {
            enumvalue = Type_BurnoutRetType::content[index].strSpec;
        }
        break;
    case _ValueUnit:
        if (index <= Type_ValueUnit::count)
        {
            enumvalue = Type_ValueUnit::content[index].strSpec;
        }
        break;
    case _ValueRange:
        if (index <= Type_ValueRange::count)
        {
            enumvalue = Type_ValueRange::content[index].strSpec;
        }
        break;
    case _SignalPolarity:
        if (index <= Type_SignalPolarity::count)
        {
            enumvalue = Type_SignalPolarity::content[index].strSpec;
        }
        break;
    case _SignalCountingType:
        if (index <= Type_SignalCountingType::count)
        {
            enumvalue = Type_SignalCountingType::content[index].strSpec;
        }
        break;
    case _OutSignalType:
        if (index <= Type_OutSignalType::count)
        {
            enumvalue = Type_OutSignalType::content[index].strSpec;
        }
        break;
    case _CounterCapability:
        if (index <= Type_CounterCapability::count)
        {
            enumvalue = Type_CounterCapability::content[index].strSpec;
        }
        break;
    case _CounterOperationMode:
        if (index <= Type_CounterOperationMode::count)
        {
            enumvalue = Type_CounterOperationMode::content[index].strSpec;
        }
        break;
    case _CounterValueRegister:
        if (index <= Type_CounterValueRegister::count)
        {
            enumvalue = Type_CounterValueRegister::content[index].strSpec;
        }
        break;
    case _CounterCascadeGroup:
        if (index <= Type_CounterCascadeGroup::count)
        {
            enumvalue = Type_CounterCascadeGroup::content[index].strSpec;
        }
        break;
    case _FreqMeasureMethod:
        if (index <= Type_FreqMeasureMethod::count)
        {
            enumvalue = Type_FreqMeasureMethod::content[index].strSpec;
        }
        break;
    case _ActiveSignal:
        if (index <= Type_ActiveSignal::count)
        {
            enumvalue = Type_ActiveSignal::content[index].strSpec;
        }
        break;
    case _TriggerAction:
        if (index <= Type_TriggerAction::count)
        {
            enumvalue = Type_TriggerAction::content[index].strSpec;
        }
        break;
    case _SignalPosition:
        if (index <= Type_SignalPosition::count)
        {
            enumvalue = Type_SignalPosition::content[index].strSpec;
        }
        break;
    case _SignalDrop:
        if (index <= Type_SignalDrop::count)
        {
            enumvalue = Type_SignalDrop::content[index].strSpec;
        }
        break;
    case _EventId:
        if (index <= Type_EventId::count)
        {
            enumvalue = Type_EventId::content[index].strSpec;
        }
        break;
    case _PropertyAttribute:
        if (index <= Type_PropertyAttribute::count)
        {
            enumvalue = Type_PropertyAttribute::content[index].strSpec;
        }
        break;
    case _PropertyId:
        if (index <= Type_PropertyID::count)
        {
            enumvalue = Type_PropertyID::content[index].strSpec;
        }
        break;
    case _ProductId:
        if (index <= Type_ProductId::count)
        {
            enumvalue = Type_ProductId::content[index].strSpec;
        }
        break;
    case _BOOL:
        if (index <= Type_Bool::count)
        {
            enumvalue = Type_Bool::content[index].strSpec;
        }
        break;
    case _NotaEnumValue:
    default:
        printf("The property id input is not a enumb type!\n");
        break;
    }
    return enumvalue;
}

int PropertyTransHelper::GetSpecEnumValueFromString(int enumtypeid, char* pszvalue)
{
    int enumvalue = -1;
    if (pszvalue == NULL)
    {
        return enumvalue;
    }
    switch (enumtypeid)
    {
    case _TerminalBoard:
        enumvalue = Type_TerminalBoard::GetPropertyID(pszvalue);  
        break;
    case _ModuleType:
        enumvalue = Type_ModuleType::GetPropertyID(pszvalue); 
        break;
    case _AccessMode:
        enumvalue = Type_AccessMode::GetPropertyID(pszvalue);
        break;
    case _MathIntervalType:
        enumvalue = Type_MathIntervalType::GetPropertyID(pszvalue);
        break;
    case _AiChannelType:
        enumvalue = Type_AiChannelType::GetPropertyID(pszvalue);
        break;
    case _AiSignalType:
        enumvalue = Type_AiSignalType::GetPropertyID(pszvalue);
        break;
    case _FilterType:
        enumvalue = Type_FilterType::GetPropertyID(pszvalue);
        break;
    case _DioPortType:
        enumvalue = Type_DioPortType::GetPropertyID(pszvalue);
        break;
    case _DioPortDir:
        enumvalue = Type_DioPortDir::GetPropertyID(pszvalue);
        break;
    case _SamplingMethod:
        enumvalue = Type_SamplingMethod::GetPropertyID(pszvalue);
        break;
    case _TemperatureDegree:
        enumvalue = Type_TemperatureDegree::GetPropertyID(pszvalue);
        break;
    case _BurnoutRetType:
        enumvalue = Type_BurnoutRetType::GetPropertyID(pszvalue);
        break;
    case _ValueUnit:
        enumvalue = Type_ValueUnit::GetPropertyID(pszvalue);
        break;
    case _ValueRange:
        enumvalue = Type_ValueRange::GetPropertyID(pszvalue);
        break;
    case _SignalPolarity:
        enumvalue = Type_SignalPolarity::GetPropertyID(pszvalue);
        break;
    case _SignalCountingType:
        enumvalue = Type_SignalCountingType::GetPropertyID(pszvalue);
        break;
    case _OutSignalType:
        enumvalue = Type_OutSignalType::GetPropertyID(pszvalue);
        break;
    case _CounterCapability:
        enumvalue = Type_CounterCapability::GetPropertyID(pszvalue);
        break;
    case _CounterOperationMode:
        enumvalue = Type_CounterOperationMode::GetPropertyID(pszvalue);
        break;
    case _CounterValueRegister:
        enumvalue = Type_CounterValueRegister::GetPropertyID(pszvalue);
        break;
    case _CounterCascadeGroup:
        enumvalue = Type_CounterCascadeGroup::GetPropertyID(pszvalue);
        break;
    case _FreqMeasureMethod:
        enumvalue = Type_FreqMeasureMethod::GetPropertyID(pszvalue);
        break;
    case _ActiveSignal:
        enumvalue = Type_ActiveSignal::GetPropertyID(pszvalue);
        break;
    case _TriggerAction:
        enumvalue = Type_TriggerAction::GetPropertyID(pszvalue);
        break;
    case _SignalPosition:
        enumvalue = Type_SignalPosition::GetPropertyID(pszvalue);
        break;
    case _SignalDrop:
        enumvalue = Type_SignalDrop::GetPropertyID(pszvalue);
        break;
    case _EventId:
        enumvalue = Type_EventId::GetPropertyID(pszvalue);
        break;
    case _PropertyAttribute:
        enumvalue = Type_PropertyAttribute::GetPropertyID(pszvalue);
        break;
    case _PropertyId:
        enumvalue = Type_PropertyID::GetPropertyID(pszvalue);
        break;
    case _ProductId:
        enumvalue = Type_ProductId::GetPropertyID(pszvalue);
        break;
    case _BOOL:
        enumvalue = Type_Bool::GetPropertyID(pszvalue);
        break;
    case _NotaEnumValue:
    default:
        printf("The property id input is not a enumb type!\n");
        break;
    }
    return enumvalue;
}

char* PropertyTransHelper::GetSpecEnumStringFromValue(int enumtypeid, int value)
{
    char* enumvalue = NULL;
    if (value < -1)
    {
        return enumvalue;
    }
    switch (enumtypeid)
    {
    case _TerminalBoard:
        enumvalue = Type_TerminalBoard::GetPropertySpec(value);  
        break;
    case _ModuleType:
        enumvalue = Type_ModuleType::GetPropertySpec(value);
        break;
    case _AccessMode:
        enumvalue = Type_AccessMode::GetPropertySpec(value);
        break;
    case _MathIntervalType:
        enumvalue = Type_MathIntervalType::GetPropertySpec(value);
        break;
    case _AiChannelType:
        enumvalue = Type_AiChannelType::GetPropertySpec(value);
        break;
    case _AiSignalType:
        enumvalue = Type_AiSignalType::GetPropertySpec(value);
        break;
    case _FilterType:
        enumvalue = Type_FilterType::GetPropertySpec(value);
        break;
    case _DioPortType:
        enumvalue = Type_DioPortType::GetPropertySpec(value);
        break;
    case _DioPortDir:
        enumvalue = Type_DioPortDir::GetPropertySpec(value);
        break;
    case _SamplingMethod:
        enumvalue = Type_SamplingMethod::GetPropertySpec(value);
        break;
    case _TemperatureDegree:
        enumvalue = Type_TemperatureDegree::GetPropertySpec(value);
        break;
    case _BurnoutRetType:
        enumvalue = Type_BurnoutRetType::GetPropertySpec(value);
        break;
    case _ValueUnit:
        enumvalue = Type_ValueUnit::GetPropertySpec(value);
        break;
    case _ValueRange:
        enumvalue = Type_ValueRange::GetPropertySpec(value);
        break;
    case _SignalPolarity:
        enumvalue = Type_SignalPolarity::GetPropertySpec(value);
        break;
    case _SignalCountingType:
        enumvalue = Type_SignalCountingType::GetPropertySpec(value);
        break;
    case _OutSignalType:
        enumvalue = Type_OutSignalType::GetPropertySpec(value);
        break;
    case _CounterCapability:
        enumvalue = Type_CounterCapability::GetPropertySpec(value);
        break;
    case _CounterOperationMode:
        enumvalue = Type_CounterOperationMode::GetPropertySpec(value);
        break;
    case _CounterValueRegister:
        enumvalue = Type_CounterValueRegister::GetPropertySpec(value);
        break;
    case _CounterCascadeGroup:
        enumvalue = Type_CounterCascadeGroup::GetPropertySpec(value);
        break;
    case _FreqMeasureMethod:
        enumvalue = Type_FreqMeasureMethod::GetPropertySpec(value);
        break;
    case _ActiveSignal:
        enumvalue = Type_ActiveSignal::GetPropertySpec(value);
        break;
    case _TriggerAction:
        enumvalue = Type_TriggerAction::GetPropertySpec(value);
        break;
    case _SignalPosition:
        enumvalue = Type_SignalPosition::GetPropertySpec(value);
        break;
    case _SignalDrop:
        enumvalue = Type_SignalDrop::GetPropertySpec(value);
        break;
    case _EventId:
        enumvalue = Type_EventId::GetPropertySpec(value);
        break;
    case _PropertyAttribute:
        enumvalue = Type_PropertyAttribute::GetPropertySpec(value);
        break;
    case _PropertyId:
        enumvalue = Type_PropertyID::GetPropertySpec(value);
        break;
    case _ProductId:
        enumvalue = Type_ProductId::GetPropertySpec(value);
        break;
    case _BOOL:
        enumvalue = Type_Bool::GetPropertySpec(value);
        break;
    case _NotaEnumValue:
    default:
        printf("The property id input is not a enumb type!\n");
        break;
    }
    return enumvalue;
}

int PropertyTransHelper::WriteStringToFile(char* filename, char* buffer, int size)
{
    /*HANDLE hFile;
    hFile = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, 
        NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 
    if (hFile == INVALID_HANDLE_VALUE)
    {
        printf("Error!!Failed to open file! \r\n");
        return -1;
    }
    SetFilePointer(hFile, NULL, NULL, FILE_END);
    DWORD dwWritenSize = 0;
    BOOL bRet = WriteFile(hFile, buffer, size, &dwWritenSize, NULL);
    if (bRet)
    {
        OutputDebugString(TEXT("WriteFile succeed!\r\n"));
    }
    CloseHandle(hFile);
	return 0;*/
	FILE* file = fopen(filename, "a");
	if (NULL != file)
	{
		int i_count_write = fwrite(buffer, size, 1, file);
		if(i_count_write != size)
		{
			printf("some data may not be write into files");
		}
		fclose(file);
	}
	else
	{
		printf("file %s open failed\r\n!", filename);
		return  -1;
	}
	return 0;
}

int PropertyTransHelper::GetIntValueFromString(int type, char* pszvalue)
{
    int value = atoi(pszvalue);
    return value;
}

unsigned long PropertyTransHelper::GetUlongValueFromString(char* pszvalue)
{
    int length = strlen(pszvalue);
    unsigned long value = 0;
    for (int i = 0; i < length; ++i)
    {
        value = (value * 10) + (unsigned long)(pszvalue[i] - '0');
    }
    return value;
}

bool PropertyTransHelper::GetBoolValueFromString(char* pszvalue)
{
    bool value = false;
    if (0 == strcmp(pszvalue, "TRUE"))
    {
        value = true;
    }
    return value;
}

double PropertyTransHelper::GetDoubleValueFromString(char* pszvalue)
{
    double value = atof(pszvalue);
    return value;
}


void PropertyTransHelper::GetIntArrayValueFromString(char* pszvalue, int type, int* pvalue, int& length)
{
    int i_begin = 0, i_end = 0, i_count = 0;
    int element_count = 0;
    int i = 0;
    do 
    {
        for (i = i_count ; i < strlen(pszvalue); ++i)
        {
            if ((pszvalue[i] == ';') || (pszvalue[i] == '\0'))
            {
                break;
            }  
        }
        char* pszsubvalue = new char[i - i_count + 1];
        memcpy(pszsubvalue, &pszvalue[i_count], i - i_count);
        pszsubvalue[i - i_count] = '\0';
        if (type == _NotaEnumValue)
        {
            pvalue[element_count] = atoi(pszsubvalue);
        }
        else
        {
            pvalue[element_count] = PropertyTransHelper::GetSpecEnumValueFromString(type, pszsubvalue);
        }
        element_count++;
        delete[] pszsubvalue;
        i_count = i + 1;
    } while (i_count < strlen(pszvalue));
    
}

void PropertyTransHelper::GetDoubleArrayValueFromString(char* pszvalue, double* pvalue, int& length)
{
    int i_begin = 0, i_end = 0, i_count = 0;
    int element_count = 0;
    int i = 0;
    do 
    {
        for (i = i_count; i < strlen(pszvalue); ++i)
        {
            if ((pszvalue[i] == ';') || (pszvalue[i] == '\0'))
            {
                break;
            }  
        }
        char* pszsubvalue = new char[i - i_count + 1];
        memcpy(pszsubvalue, &pszvalue[i_count], i - i_count);
        pszsubvalue[i - i_count] = '\0';
        pvalue[element_count] = atof(pszsubvalue);
        element_count++;
        delete[] pszsubvalue;
        i_count = i + 1;
    } while (i_count < strlen(pszvalue));
}

//////////////////////
SPEC_PROPERTY Type_CtrlType::content[TYPE_CTRLTYPE] = {
    _AiFeatures,                 "AiFeatures",
    _InstantAiCtrl,              "InstantAiCtrl",
    _BufferAiCtrl,               "BufferAiCtrl",
    _AoFeatures,                 "AoFeatures",
    _InstantAoCtrl,              "InstantAoCtrl",
    _BufferedAoCtrl,             "BufferedAoCtrl",
    _DioFeatures,                "DioFeatures",
    _DiFeatures,                 "DiFeatures",
    _InstantDiCtrl,              "InstantDiCtrl",
    _BufferedDiCtrl,             "BufferedDiCtrl",
    _DoFeatures,                 "DoFeatures",
    _InstantDoCtrl,              "InstantDoCtrl",
    _BufferedDoCtrl,             "BufferedDoCtrl",
    _CounterCapabilityIndexer,   "CounterCapabilityIndexer",
    _CntrFeatures,               "CntrFeatures",
    _CntrFeaturesExt,            "CntrFeaturesExt",
    _CntrCtrlExt,                "CntrCtrlExt",
    _EventCounterCtrl,           "EventCounterCtrl",
    _FreqMeterFeatures,          "FreqMeterFeatures",
    _FreqMeterCtrl,              "FreqMeterCtrl",
    _OneShotFeatures,            "OneShotFeatures",
    _OneShotCtrl,                "OneShotCtrl",
    _TimerPulseFeatures,         "TimerPulseFeatures",
    _TimerPulseCtrl,             "TimerPulseCtrl",
    _PwMeterFeatures,            "PwMeterFeatures",
    _PwMeterCtrl,                "PwMeterCtrl",
    _PwModulatorFeatures,        "PwModulatorFeatures",
    _PwModulatorCtrl,            "PwModulatorCtrl",
    _UdCounterFeatures,          "UdCounterFeatures",
    _UdCounterCtrl,              "UdCounterCtrl",
    _AiCtrlBase,                "AiCtrlBase",
    _AoCtrlBase,                "AoCtrlBase",
    _DioCtrlBase,               "DioCtrlBase",
    _DiCtrlBase,                "DiCtrlBase",
    _DoCtrlBase,                "DoCtrlBase",
    _CntrCtrlBase,              "CntrCtrlBase"
};

int Type_CtrlType::count = TYPE_CTRLTYPE;

char* Type_CtrlType::GetPropertySpec(int id)
{
    for (int i = 0; i < Type_CtrlType::count; ++i)
    {
        if (Type_CtrlType::content[i].iID == id)
        {
            return Type_CtrlType::content[i].strSpec;
        }
    }
    return "undefine ID";
}

int Type_CtrlType::GetPropertyID(char* caption)
{
    for (int i = 0; i < Type_CtrlType::count; ++i)
    {
        if (0 == strcmp(caption,Type_CtrlType::content[i].strSpec))
        {
            return Type_CtrlType::content[i].iID;
        }
    }
    return -1;
}
